@2kw/ai-mcp-server 4.0.0-dev.2

package/dist/tools/prompts.js

@@ -0,0 +1,373 @@
+import { z } from "zod";
+import { formatErrorForMcp } from "../errors.js";
+export function register(server, client) {
+    // ── prompts ─────────────────────────────────────────────────────────────
+    server.tool("2kw_list_prompts", "List org prompts with optional name/type filter and pagination.", {
+        search: z.string().optional().describe("Filter by name"),
+        type: z.enum(["TEXT", "CHAT"]).optional().describe("Filter by type"),
+        page: z.number().int().min(0).optional(),
+        size: z.number().int().min(1).max(100).optional(),
+        sort: z.string().optional().describe("Sort field and direction"),
+    }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/prompts", {
+                params: {
+                    query: {
+                        search: params.search,
+                        type: params.type,
+                        pageable: {
+                            page: params.page ?? 0,
+                            size: params.size ?? 20,
+                            sort: params.sort ? [params.sort] : undefined,
+                        },
+                    },
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_get_prompt", "Get a single prompt by id, including its active version pointer.", { promptId: z.string() }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/prompts/{id}", {
+                params: { path: { id: 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_create_prompt", "Create a new prompt (metadata only — add content via a prompt version).", {
+        name: z.string().min(1),
+        description: z.string().optional(),
+        type: z.enum(["TEXT", "CHAT"]).optional().describe("Prompt type (default TEXT)"),
+    }, async (params) => {
+        try {
+            const { data } = await client.POST("/v1/prompts", {
+                body: {
+                    name: params.name,
+                    description: params.description,
+                    type: params.type ?? "TEXT",
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_update_prompt", "Update prompt metadata (name, description, type).", {
+        promptId: z.string(),
+        name: z.string().optional(),
+        description: z.string().optional(),
+        type: z.enum(["TEXT", "CHAT"]).optional(),
+    }, async (params) => {
+        try {
+            const body = {};
+            if (params.name !== undefined)
+                body.name = params.name;
+            if (params.description !== undefined)
+                body.description = params.description;
+            if (params.type !== undefined)
+                body.type = params.type;
+            const { data } = await client.PUT("/v1/prompts/{id}", {
+                params: { path: { id: params.promptId } },
+                body: body,
+            });
+            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", "Delete a prompt and all its versions. Irreversible.", { promptId: z.string() }, async (params) => {
+        try {
+            await client.DELETE("/v1/prompts/{id}", {
+                params: { path: { id: params.promptId } },
+            });
+            return {
+                content: [
+                    { type: "text", text: `Prompt ${params.promptId} deleted.` },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_resolve_prompt", "Resolve a prompt's active or labeled content — returns the version that would be used at runtime.", {
+        promptId: z.string(),
+        label: z.string().optional().describe("Label (e.g. 'production') — otherwise returns active"),
+    }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/prompts/{promptId}/resolve", {
+                params: {
+                    path: { promptId: params.promptId },
+                    query: { label: params.label },
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_compile_prompt", "Render a prompt template with variable substitution. Pass variables as an object; unresolved placeholders will error.", {
+        promptId: z.string(),
+        variables: z.record(z.string(), z.unknown()).optional(),
+        versionId: z.string().optional().describe("Compile a specific version"),
+        label: z.string().optional().describe("Compile the version behind this label"),
+    }, async (params) => {
+        try {
+            const { data } = await client.POST("/v1/prompts/{promptId}/compile", {
+                params: { path: { promptId: params.promptId } },
+                body: {
+                    variables: params.variables,
+                    versionId: params.versionId,
+                    label: params.label,
+                },
+            });
+            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_prompt", "Run a prompt against an LLM and return the completion — useful for smoke-testing template changes.", {
+        promptId: z.string(),
+        model: z.string().describe("provider/model, e.g. openai/gpt-4.1"),
+        content: z.string().optional().describe("Optional input text"),
+        variables: z.record(z.string(), z.unknown()).optional(),
+        versionId: z.string().optional(),
+        label: z.string().optional(),
+    }, async (params) => {
+        try {
+            const { data } = await client.POST("/v1/prompts/{promptId}/test", {
+                params: { path: { promptId: params.promptId } },
+                body: {
+                    model: params.model,
+                    content: params.content,
+                    variables: params.variables,
+                    versionId: params.versionId,
+                    label: params.label,
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── versions ────────────────────────────────────────────────────────────
+    server.tool("2kw_list_prompt_versions", "List all versions of a prompt (most recent first).", {
+        promptId: z.string(),
+        page: z.number().int().min(0).optional(),
+        size: z.number().int().min(1).max(100).optional(),
+    }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/prompts/{promptId}/versions", {
+                params: {
+                    path: { promptId: params.promptId },
+                    query: {
+                        pageable: { page: params.page ?? 0, size: params.size ?? 20 },
+                    },
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_get_prompt_version", "Fetch a single prompt version by id, including its content.", { promptId: z.string(), versionId: z.string() }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/prompts/{promptId}/versions/{versionId}", {
+                params: {
+                    path: { promptId: params.promptId, versionId: params.versionId },
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        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"),
+        changeDescription: z.string().optional(),
+    }, async (params) => {
+        try {
+            const { data } = await client.POST("/v1/prompts/{promptId}/versions", {
+                params: { path: { promptId: params.promptId } },
+                body: {
+                    content: params.content,
+                    changeDescription: params.changeDescription,
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_activate_prompt_version", "Mark a specific prompt version as active — new resolve/test calls with no label target this version.", { promptId: z.string(), versionId: z.string() }, async (params) => {
+        try {
+            const { data } = await client.PUT("/v1/prompts/{promptId}/versions/{versionId}/activate", {
+                params: {
+                    path: { promptId: params.promptId, versionId: params.versionId },
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── labels ──────────────────────────────────────────────────────────────
+    server.tool("2kw_list_prompt_labels", "List labels defined on a prompt (e.g. production, staging) and which version each points to.", { promptId: z.string() }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/prompts/{promptId}/labels", {
+                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_create_prompt_label", "Label a prompt version (e.g. tag a version as 'production'). Labels are unique per prompt.", {
+        promptId: z.string(),
+        name: z.string().describe("Label name (e.g. 'production')"),
+        promptVersionId: z.string().describe("Version id the label should point to"),
+    }, async (params) => {
+        try {
+            const { data } = await client.POST("/v1/prompts/{promptId}/labels", {
+                params: { path: { promptId: params.promptId } },
+                body: { name: params.name, promptVersionId: params.promptVersionId },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_update_prompt_label", "Move an existing label to a different prompt version — typical release cutover.", {
+        promptId: z.string(),
+        labelName: z.string(),
+        promptVersionId: z.string(),
+    }, async (params) => {
+        try {
+            const { data } = await client.PUT("/v1/prompts/{promptId}/labels/{labelName}", {
+                params: {
+                    path: { promptId: params.promptId, labelName: params.labelName },
+                },
+                body: { promptVersionId: params.promptVersionId },
+            });
+            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_label", "Remove a label from a prompt. Does not affect the version it was pointing to.", { promptId: z.string(), labelName: z.string() }, async (params) => {
+        try {
+            await client.DELETE("/v1/prompts/{promptId}/labels/{labelName}", {
+                params: {
+                    path: { promptId: params.promptId, labelName: params.labelName },
+                },
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Label "${params.labelName}" deleted from prompt ${params.promptId}.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=prompts.js.map

package/dist/tools/providers.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=providers.d.ts.map

package/dist/tools/providers.js

@@ -0,0 +1,148 @@
+import { z } from "zod";
+import { formatErrorForMcp } from "../errors.js";
+const ProviderType = z.enum([
+    "OPENAI",
+    "AZURE_OPENAI",
+    "ANTHROPIC",
+    "XAI",
+    "MISTRAL",
+    "VERTEX_AI",
+    "OLLAMA",
+]);
+export function register(server, client) {
+    server.tool("2kw_list_providers", "List BYOK AI providers configured for the org (OpenAI, Azure, Anthropic, etc.).", {
+        search: z.string().optional(),
+        page: z.number().int().min(0).optional(),
+        size: z.number().int().min(1).max(100).optional(),
+    }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/providers", {
+                params: {
+                    query: {
+                        search: params.search,
+                        pageable: { page: params.page ?? 0, size: params.size ?? 20 },
+                    },
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_get_provider", "Fetch a single provider record by id. API keys are redacted.", { id: z.string() }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/providers/{id}", {
+                params: { path: { id: params.id } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_create_provider", "Register a new BYOK provider with credentials. Requires an API key belonging to the external provider.", {
+        name: z.string(),
+        provider: ProviderType.describe("Provider vendor type"),
+        apiKey: z.string().describe("Credential for the external provider"),
+        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", {
+                body: {
+                    name: params.name,
+                    provider: params.provider,
+                    apiKey: params.apiKey,
+                    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_update_provider", "Patch an existing provider. Only supplied fields are updated.", {
+        id: z.string(),
+        name: z.string().optional(),
+        provider: ProviderType.optional(),
+        enabled: z.boolean().optional(),
+        config: z.record(z.string(), z.unknown()).optional(),
+    }, async (params) => {
+        try {
+            const body = {};
+            if (params.name !== undefined)
+                body.name = params.name;
+            if (params.provider !== undefined)
+                body.provider = params.provider;
+            if (params.enabled !== undefined)
+                body.enabled = params.enabled;
+            if (params.config !== undefined)
+                body.config = params.config;
+            const { data } = await client.PATCH("/v1/providers/{id}", {
+                params: { path: { id: params.id } },
+                body: body,
+            });
+            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_provider", "Delete a provider. Existing extractions that used it keep their past records.", { id: z.string() }, async (params) => {
+        try {
+            await client.DELETE("/v1/providers/{id}", {
+                params: { path: { id: params.id } },
+            });
+            return {
+                content: [
+                    { type: "text", text: `Provider ${params.id} deleted.` },
+                ],
+            };
+        }
+        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");
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=providers.js.map

package/dist/tools/schema-labels.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=schema-labels.d.ts.map

package/dist/tools/schema-labels.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { formatErrorForMcp } from "../errors.js";
+export function register(server, client) {
+    server.tool("2kw_list_schema_labels", "List labels defined on a schema (e.g. production, staging) and which version each points to.", { schemaId: z.string() }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/schemas/{schemaId}/labels", {
+                params: { path: { schemaId: params.schemaId } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_create_schema_label", "Label a schema version (e.g. tag as 'production'). Labels are unique per schema.", {
+        schemaId: z.string(),
+        name: z.string().describe("Label name"),
+        schemaVersionId: z.string().describe("Version id the label should point to"),
+    }, async (params) => {
+        try {
+            const { data } = await client.POST("/v1/schemas/{schemaId}/labels", {
+                params: { path: { schemaId: params.schemaId } },
+                body: { name: params.name, schemaVersionId: params.schemaVersionId },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_update_schema_label", "Move an existing schema label to a different version — typical release cutover.", {
+        schemaId: z.string(),
+        labelName: z.string(),
+        schemaVersionId: z.string(),
+    }, async (params) => {
+        try {
+            const { data } = await client.PUT("/v1/schemas/{schemaId}/labels/{labelName}", {
+                params: {
+                    path: { schemaId: params.schemaId, labelName: params.labelName },
+                },
+                body: { schemaVersionId: params.schemaVersionId },
+            });
+            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_schema_label", "Remove a label from a schema. Does not affect the version it was pointing to.", { schemaId: z.string(), labelName: z.string() }, async (params) => {
+        try {
+            await client.DELETE("/v1/schemas/{schemaId}/labels/{labelName}", {
+                params: {
+                    path: { schemaId: params.schemaId, labelName: params.labelName },
+                },
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Label "${params.labelName}" deleted from schema ${params.schemaId}.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=schema-labels.js.map

package/dist/tools/schema-testing.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=schema-testing.d.ts.map