@manfred-kunze-dev/backbone-mcp-server 2.6.0-dev.4

package/dist/tools/extraction.js

@@ -0,0 +1,252 @@
+import { z } from "zod";
+import { readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
+import { formatErrorForMcp } from "../errors.js";
+const IMAGE_MIME_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+};
+export function register(server, client) {
+    // ── create_extraction ───────────────────────────────────────────────────
+    server.tool("backbone_create_extraction", "Extract structured data from text and/or images using a schema and AI model. Supports text-only, vision (images), or combined extraction. Use a vision-capable model (e.g. openai/gpt-4o) when providing images.", {
+        projectId: z.string().describe("The project ID"),
+        schemaId: z.string().describe("The schema ID to extract with"),
+        schemaVersionId: z
+            .string()
+            .optional()
+            .describe("Specific schema version ID (uses latest active version if omitted)"),
+        inputText: z
+            .string()
+            .optional()
+            .describe("The text to extract structured data from (required unless inputImages provided)"),
+        inputImages: z
+            .array(z.object({
+            type: z.enum(["base64", "file"]).describe("Source type: 'base64' for pre-encoded data, 'file' for local file path"),
+            data: z.string().optional().describe("Base64-encoded image data (when type='base64')"),
+            path: z.string().optional().describe("Local file path to image (when type='file')"),
+            mimeType: z.string().optional().describe("MIME type (auto-detected for files, required for base64)"),
+        }))
+            .optional()
+            .describe("Images for vision extraction (max 10). Requires a vision-capable model."),
+        model: z.string().describe("AI model in 'provider/model' format"),
+        async: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("If true, submit as async extraction and return immediately (not supported with images)"),
+    }, async ({ projectId, schemaId, schemaVersionId, inputText, inputImages, model, async: isAsync }) => {
+        try {
+            // Resolve images: read local files and convert to base64
+            const resolvedImages = [];
+            if (inputImages?.length) {
+                for (const img of inputImages) {
+                    if (img.type === "file") {
+                        if (!img.path)
+                            throw new Error("path is required for type='file'");
+                        const fileBuffer = await readFile(img.path);
+                        const ext = extname(img.path).toLowerCase();
+                        const mimeType = img.mimeType ?? IMAGE_MIME_TYPES[ext];
+                        if (!mimeType)
+                            throw new Error(`Cannot determine MIME type for ${basename(img.path)}. Supported: ${Object.keys(IMAGE_MIME_TYPES).join(", ")}`);
+                        resolvedImages.push({ data: fileBuffer.toString("base64"), mimeType });
+                    }
+                    else {
+                        if (!img.data)
+                            throw new Error("data is required for type='base64'");
+                        if (!img.mimeType)
+                            throw new Error("mimeType is required for type='base64'");
+                        resolvedImages.push({ data: img.data, mimeType: img.mimeType });
+                    }
+                }
+            }
+            const body = {
+                schemaId,
+                model,
+                ...(inputText && { inputText }),
+                ...(resolvedImages.length > 0 && { inputImages: resolvedImages }),
+                ...(schemaVersionId && { schemaVersionId }),
+            };
+            if (isAsync) {
+                const { data } = await client.POST("/v1/projects/{projectId}/extractions/async", {
+                    params: { path: { projectId } },
+                    body,
+                });
+                const result = data;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Extraction submitted (id: ${result.id}, status: ${result.status}). Poll with backbone_get_extraction to check progress.`,
+                        },
+                    ],
+                };
+            }
+            const { data } = await client.POST("/v1/projects/{projectId}/extractions", {
+                params: { path: { projectId } },
+                body,
+            });
+            const result = data;
+            if (result.status === "PENDING" || result.status === "PROCESSING") {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Extraction submitted (id: ${result.id}, status: ${result.status}). Poll with backbone_get_extraction to check progress.`,
+                        },
+                    ],
+                };
+            }
+            return { content: formatExtractionResult(result) };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── get_extraction ──────────────────────────────────────────────────────
+    server.tool("backbone_get_extraction", "Get an extraction by its ID. Use this to check the status of async extractions or retrieve results.", {
+        projectId: z.string().describe("The project ID"),
+        extractionId: z.string().describe("The extraction ID"),
+    }, async ({ projectId, extractionId }) => {
+        try {
+            const { data } = await client.GET("/v1/projects/{projectId}/extractions/{id}", {
+                params: { path: { projectId, id: extractionId } },
+            });
+            return { content: formatExtractionResult(data) };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── list_extractions ────────────────────────────────────────────────────
+    server.tool("backbone_list_extractions", "List extractions within a project with optional filtering by status, schema version, or search term.", {
+        projectId: z.string().describe("The project ID"),
+        status: z
+            .enum(["PENDING", "PROCESSING", "COMPLETED", "FAILED"])
+            .optional()
+            .describe("Filter by extraction status"),
+        schemaVersionId: z.string().optional().describe("Filter by schema version ID"),
+        search: z.string().optional().describe("Search by model name"),
+        page: z.number().optional().default(0).describe("Page number (0-based)"),
+        size: z.number().optional().default(20).describe("Page size"),
+        sort: z.string().optional().describe("Sort field and direction (default: createdAt,desc)"),
+    }, async ({ projectId, status, schemaVersionId, search, page, size, sort }) => {
+        try {
+            const { data } = await client.GET("/v1/projects/{projectId}/extractions", {
+                params: {
+                    path: { projectId },
+                    query: {
+                        status,
+                        schemaVersionId,
+                        search,
+                        page,
+                        size,
+                        sort: sort ? [sort] : undefined,
+                    },
+                },
+            });
+            const result = data;
+            const lines = (result.content ?? []).map((e) => `- ${e.id} [${e.status}] model=${e.model} schema=${e.schemaId}${e.errorMessage ? ` error: ${e.errorMessage}` : ""}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Extractions (${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,
+            };
+        }
+    });
+    // ── estimate_tokens ─────────────────────────────────────────────────────
+    server.tool("backbone_estimate_tokens", "Estimate token usage for an extraction without executing it. Useful for cost estimation.", {
+        projectId: z.string().describe("The project ID"),
+        schemaId: z.string().describe("The schema ID"),
+        schemaVersionId: z.string().optional().describe("Specific schema version ID"),
+        inputText: z.string().describe("The text to estimate tokens for"),
+    }, async ({ projectId, schemaId, schemaVersionId, inputText }) => {
+        try {
+            const { data } = await client.POST("/v1/projects/{projectId}/extractions/estimate", {
+                params: { path: { projectId } },
+                body: {
+                    schemaId,
+                    inputText,
+                    ...(schemaVersionId && { schemaVersionId }),
+                },
+            });
+            const result = data;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Token estimate:\n  Input tokens: ${result.inputTokens}\n  Estimated output tokens: ${result.estimatedOutputTokens}\n  Strategy: ${result.strategy}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── rerun_extraction ────────────────────────────────────────────────────
+    server.tool("backbone_rerun_extraction", "Re-run an existing extraction with the same configuration. Creates a new extraction.", {
+        projectId: z.string().describe("The project ID"),
+        extractionId: z.string().describe("The extraction ID to re-run"),
+    }, async ({ projectId, extractionId }) => {
+        try {
+            const { data } = await client.POST("/v1/projects/{projectId}/extractions/{id}/rerun", {
+                params: { path: { projectId, id: extractionId } },
+            });
+            return { content: formatExtractionResult(data) };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+}
+function formatExtractionResult(extraction) {
+    const parts = [];
+    parts.push({
+        type: "text",
+        text: `Extraction ${extraction.id} [${extraction.status}]\nModel: ${extraction.model}${extraction.strategy ? `\nStrategy: ${extraction.strategy}` : ""}`,
+    });
+    if (extraction.status === "COMPLETED" && extraction.result) {
+        parts.push({
+            type: "text",
+            text: `Result:\n${JSON.stringify(extraction.result, null, 2)}`,
+        });
+    }
+    if (extraction.status === "FAILED" && extraction.errorMessage) {
+        parts.push({
+            type: "text",
+            text: `Error: ${extraction.errorMessage}`,
+        });
+    }
+    if (extraction.estimatedInputTokens != null) {
+        parts.push({
+            type: "text",
+            text: `Tokens: ~${extraction.estimatedInputTokens} input, ~${extraction.estimatedOutputTokens} output`,
+        });
+    }
+    return parts;
+}
+//# sourceMappingURL=extraction.js.map

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

package/dist/tools/projects.js

@@ -0,0 +1,129 @@
+import { z } from "zod";
+import { formatErrorForMcp } from "../errors.js";
+export function register(server, client) {
+    // ── list_projects ───────────────────────────────────────────────────────
+    server.tool("backbone_list_projects", "List projects in the organization with optional search and pagination.", {
+        search: z.string().optional().describe("Filter projects by name"),
+        page: z.number().optional().default(0).describe("Page number (0-based)"),
+        size: z.number().optional().default(20).describe("Page size"),
+        sort: z.string().optional().describe("Sort field and direction, e.g. 'name,asc'"),
+    }, async ({ search, page, size, sort }) => {
+        try {
+            const { data } = await client.GET("/v1/projects", {
+                params: {
+                    query: {
+                        search,
+                        page,
+                        size,
+                        sort: sort ? [sort] : undefined,
+                    },
+                },
+            });
+            const result = data;
+            const lines = (result.content ?? []).map((p) => `- ${p.name} (id: ${p.id})${p.description ? ` — ${p.description}` : ""}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Projects (${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_project ─────────────────────────────────────────────────────────
+    server.tool("backbone_get_project", "Get a project by its ID.", {
+        projectId: z.string().describe("The project ID"),
+    }, async ({ projectId }) => {
+        try {
+            const { data } = await client.GET("/v1/projects/{id}", {
+                params: { path: { id: projectId } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── create_project ──────────────────────────────────────────────────────
+    server.tool("backbone_create_project", "Create a new project in the organization.", {
+        name: z.string().min(1).max(255).describe("Project name"),
+        description: z.string().max(1000).optional().describe("Project description"),
+    }, async ({ name, description }) => {
+        try {
+            const { data } = await client.POST("/v1/projects", {
+                body: {
+                    name,
+                    ...(description !== undefined && { description }),
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── update_project ──────────────────────────────────────────────────────
+    server.tool("backbone_update_project", "Update an existing project.", {
+        projectId: z.string().describe("The project ID"),
+        name: z.string().min(1).max(255).optional().describe("New project name"),
+        description: z.string().max(1000).optional().describe("New project description"),
+    }, async ({ projectId, name, description }) => {
+        try {
+            const body = {};
+            if (name !== undefined)
+                body.name = name;
+            if (description !== undefined)
+                body.description = description;
+            const { data } = await client.PUT("/v1/projects/{id}", {
+                params: { path: { id: projectId } },
+                body: body,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── delete_project ──────────────────────────────────────────────────────
+    server.tool("backbone_delete_project", "Delete a project and all its associated data (schemas, extractions). This action is irreversible.", {
+        projectId: z.string().describe("The project ID to delete"),
+    }, async ({ projectId }) => {
+        try {
+            await client.DELETE("/v1/projects/{id}", {
+                params: { path: { id: projectId } },
+            });
+            return {
+                content: [{ type: "text", text: `Project ${projectId} deleted successfully.` }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=projects.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

package/dist/tools/schema-testing.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { formatErrorForMcp } from "../errors.js";
+import { ensureOpenAiCompatible } from "../schema-compat.js";
+/* ── helpers ─────────────────────────────────────────────────────────────── */
+function formatTestResult(result) {
+    const parts = [];
+    parts.push(`Success: ${result.success}`);
+    if (result.extractedData) {
+        parts.push(`Extracted data:\n${JSON.stringify(result.extractedData, null, 2)}`);
+    }
+    if (result.error) {
+        parts.push(`Error: ${result.error}`);
+    }
+    if (result.modelUsed) {
+        parts.push(`Model: ${result.modelUsed}`);
+    }
+    if (result.inputTokens != null || result.outputTokens != null) {
+        parts.push(`Tokens: ${result.inputTokens ?? 0} input, ${result.outputTokens ?? 0} output`);
+    }
+    if (result.processingDurationMs != null) {
+        parts.push(`Processing time: ${result.processingDurationMs}ms`);
+    }
+    return parts.join("\n");
+}
+export function register(server, client) {
+    // ── validate_schema ─────────────────────────────────────────────────────
+    server.tool("backbone_validate_schema", "Validate a JSON Schema definition without persisting it. Returns validation errors and warnings.", {
+        projectId: z.string().describe("The project ID"),
+        schemaId: z.string().describe("The schema ID"),
+        jsonSchema: z.unknown().describe("The JSON Schema to validate"),
+    }, async ({ projectId, schemaId, jsonSchema }) => {
+        try {
+            const { data } = await client.POST("/v1/projects/{projectId}/schemas/{schemaId}/validate", {
+                params: { path: { projectId, schemaId } },
+                body: {
+                    jsonSchema: ensureOpenAiCompatible(jsonSchema),
+                },
+            });
+            const result = data;
+            const parts = [];
+            parts.push(`Valid: ${result.valid}`);
+            if (result.errors && result.errors.length > 0) {
+                parts.push(`\nErrors:\n${result.errors.map((e) => `  - ${e}`).join("\n")}`);
+            }
+            if (result.warnings && result.warnings.length > 0) {
+                parts.push(`\nWarnings:\n${result.warnings.map((w) => `  - ${w}`).join("\n")}`);
+            }
+            return {
+                content: [{ type: "text", text: parts.join("\n") }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── test_schema ─────────────────────────────────────────────────────────
+    server.tool("backbone_test_schema", "Test a JSON Schema against sample text using AI extraction. Returns the extraction result and token usage without creating a persistent extraction.", {
+        projectId: z.string().describe("The project ID"),
+        schemaId: z.string().describe("The schema ID"),
+        jsonSchema: z.unknown().describe("The JSON Schema to test"),
+        sampleText: z.string().describe("Sample text to extract data from"),
+        model: z.string().describe("AI model in 'provider/model' format (e.g. 'openai/gpt-4o')"),
+    }, async ({ projectId, schemaId, jsonSchema, sampleText, model }) => {
+        try {
+            // Create a temporary version with this schema content, then test
+            // The API uses stored schema versions; we create one, test, then the caller can delete
+            // Actually the test endpoint accepts text + model + optional schemaVersionId
+            // We first need to create a version, then test against it
+            // For simplicity, we create a version inline and use its ID
+            const versionResult = await client.POST("/v1/projects/{projectId}/schemas/{schemaId}/versions", {
+                params: { path: { projectId, schemaId } },
+                body: {
+                    jsonSchema: ensureOpenAiCompatible(jsonSchema),
+                    changeDescription: "Test version",
+                },
+            });
+            const version = versionResult.data;
+            const { data } = await client.POST("/v1/projects/{projectId}/schemas/{schemaId}/test", {
+                params: { path: { projectId, schemaId } },
+                body: {
+                    jsonSchema: ensureOpenAiCompatible(jsonSchema),
+                    sampleText,
+                    model,
+                },
+            });
+            const result = data;
+            return {
+                content: [{ type: "text", text: formatTestResult(result) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=schema-testing.js.map

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

package/dist/tools/schema-versions.js

@@ -0,0 +1,129 @@
+import { z } from "zod";
+import { formatErrorForMcp } from "../errors.js";
+import { ensureOpenAiCompatible } from "../schema-compat.js";
+export function register(server, client) {
+    // ── create_schema_version ───────────────────────────────────────────────
+    server.tool("backbone_create_schema_version", "Create a new version for a schema. The new version becomes the active one.", {
+        projectId: z.string().describe("The project ID"),
+        schemaId: z.string().describe("The schema ID"),
+        jsonSchema: z.unknown().describe("The JSON Schema definition for this version"),
+        changeDescription: z
+            .string()
+            .optional()
+            .describe("Description of what changed in this version"),
+    }, async ({ projectId, schemaId, jsonSchema, changeDescription }) => {
+        try {
+            const { data } = await client.POST("/v1/projects/{projectId}/schemas/{schemaId}/versions", {
+                params: { path: { projectId, schemaId } },
+                body: {
+                    jsonSchema: ensureOpenAiCompatible(jsonSchema),
+                    ...(changeDescription && { changeDescription }),
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── list_schema_versions ────────────────────────────────────────────────
+    server.tool("backbone_list_schema_versions", "List all versions of a schema with pagination.", {
+        projectId: z.string().describe("The project ID"),
+        schemaId: z.string().describe("The schema ID"),
+        page: z.number().optional().default(0).describe("Page number (0-based)"),
+        size: z.number().optional().default(20).describe("Page size"),
+    }, async ({ projectId, schemaId, page, size }) => {
+        try {
+            const { data } = await client.GET("/v1/projects/{projectId}/schemas/{schemaId}/versions", {
+                params: {
+                    path: { projectId, schemaId },
+                    query: { page, size },
+                },
+            });
+            const result = data;
+            const lines = (result.content ?? []).map((v) => `- v${v.versionNumber} (id: ${v.id}) ${v.isActive ? "[ACTIVE]" : "[inactive]"}${v.changeDescription ? ` — ${v.changeDescription}` : ""}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Schema 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_schema_version ──────────────────────────────────────────────────
+    server.tool("backbone_get_schema_version", "Get a specific schema version by its ID.", {
+        projectId: z.string().describe("The project ID"),
+        schemaId: z.string().describe("The schema ID"),
+        versionId: z.string().describe("The version ID"),
+    }, async ({ projectId, schemaId, versionId }) => {
+        try {
+            const { data } = await client.GET("/v1/projects/{projectId}/schemas/{schemaId}/versions/{versionId}", {
+                params: { path: { projectId, schemaId, versionId } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── get_latest_schema_version ───────────────────────────────────────────
+    server.tool("backbone_get_latest_schema_version", "Get the latest active version of a schema.", {
+        projectId: z.string().describe("The project ID"),
+        schemaId: z.string().describe("The schema ID"),
+    }, async ({ projectId, schemaId }) => {
+        try {
+            const { data } = await client.GET("/v1/projects/{projectId}/schemas/{schemaId}/versions/latest", {
+                params: { path: { projectId, schemaId } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── activate_schema_version ─────────────────────────────────────────────
+    server.tool("backbone_activate_schema_version", "Re-activate a historical schema version by creating a copy as the newest active version.", {
+        projectId: z.string().describe("The project ID"),
+        schemaId: z.string().describe("The schema ID"),
+        versionId: z.string().describe("The version ID to activate"),
+    }, async ({ projectId, schemaId, versionId }) => {
+        try {
+            const { data } = await client.PUT("/v1/projects/{projectId}/schemas/{schemaId}/versions/{versionId}/activate", {
+                params: { path: { projectId, schemaId, versionId } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=schema-versions.js.map

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