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

package/dist/tools/schemas.js

@@ -0,0 +1,138 @@
+import { z } from "zod";
+import { formatErrorForMcp } from "../errors.js";
+export function register(server, client) {
+    // ── list_schemas ────────────────────────────────────────────────────────
+    server.tool("backbone_list_schemas", "List schemas within a project with optional search and pagination.", {
+        projectId: z.string().describe("The project ID"),
+        search: z.string().optional().describe("Filter schemas 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"),
+    }, async ({ projectId, search, page, size, sort }) => {
+        try {
+            const { data } = await client.GET("/v1/projects/{projectId}/schemas", {
+                params: {
+                    path: { projectId },
+                    query: {
+                        search,
+                        page,
+                        size,
+                        sort: sort ? [sort] : undefined,
+                    },
+                },
+            });
+            const result = data;
+            const lines = (result.content ?? []).map((s) => `- ${s.name} (id: ${s.id})${s.description ? ` — ${s.description}` : ""}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Schemas (${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 ──────────────────────────────────────────────────────────
+    server.tool("backbone_get_schema", "Get a schema by its ID.", {
+        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/{id}", {
+                params: { path: { projectId, id: schemaId } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── create_schema ───────────────────────────────────────────────────────
+    server.tool("backbone_create_schema", "Create a new schema within a project.", {
+        projectId: z.string().describe("The project ID"),
+        name: z.string().min(1).describe("Schema name"),
+        description: z.string().optional().describe("Schema description"),
+    }, async ({ projectId, name, description }) => {
+        try {
+            const { data } = await client.POST("/v1/projects/{projectId}/schemas", {
+                params: { path: { projectId } },
+                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_schema ───────────────────────────────────────────────────────
+    server.tool("backbone_update_schema", "Update an existing schema.", {
+        projectId: z.string().describe("The project ID"),
+        schemaId: z.string().describe("The schema ID"),
+        name: z.string().optional().describe("New schema name"),
+        description: z.string().optional().describe("New schema description"),
+    }, async ({ projectId, schemaId, name, description }) => {
+        try {
+            const body = {};
+            if (name !== undefined)
+                body.name = name;
+            if (description !== undefined)
+                body.description = description;
+            const { data } = await client.PUT("/v1/projects/{projectId}/schemas/{id}", {
+                params: { path: { projectId, id: schemaId } },
+                body: body,
+            });
+            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("backbone_delete_schema", "Delete a schema and all its versions. This action is irreversible.", {
+        projectId: z.string().describe("The project ID"),
+        schemaId: z.string().describe("The schema ID to delete"),
+    }, async ({ projectId, schemaId }) => {
+        try {
+            await client.DELETE("/v1/projects/{projectId}/schemas/{id}", {
+                params: { path: { projectId, id: schemaId } },
+            });
+            return {
+                content: [
+                    { type: "text", text: `Schema ${schemaId} deleted successfully.` },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=schemas.js.map

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

package/dist/tools/transcription.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { formatErrorForMcp } from "../errors.js";
+import { getMimeType } from "../mime.js";
+export function register(server, client) {
+    server.tool("backbone_transcribe_audio", "Transcribe an audio file using Backbone's transcription API. Supports flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, webm. Reads local files automatically.", {
+        filePath: z.string().describe("Local path to the audio file"),
+        model: z
+            .string()
+            .describe("Transcription model in 'provider/model' format (e.g. 'openai/whisper-1')"),
+        language: z
+            .string()
+            .optional()
+            .describe("ISO-639-1 language code (e.g. 'en', 'de')"),
+        prompt: z
+            .string()
+            .optional()
+            .describe("Text to guide the transcription style/context"),
+        responseFormat: z
+            .enum(["json", "text", "srt", "verbose_json", "vtt"])
+            .optional()
+            .describe("Response format (default: json)"),
+        temperature: z
+            .number()
+            .min(0)
+            .max(1)
+            .optional()
+            .describe("Sampling temperature (0-1)"),
+    }, async ({ filePath, model, language, prompt, responseFormat, temperature }) => {
+        try {
+            const fileBuffer = await readFile(filePath);
+            const filename = basename(filePath);
+            const mimeType = getMimeType(filename);
+            const formData = new FormData();
+            formData.append("file", new Blob([fileBuffer], { type: mimeType }), filename);
+            formData.append("model", model);
+            if (language)
+                formData.append("language", language);
+            if (prompt)
+                formData.append("prompt", prompt);
+            if (responseFormat)
+                formData.append("response_format", responseFormat);
+            if (temperature !== undefined)
+                formData.append("temperature", String(temperature));
+            const { data } = await client.POST("/v1/audio/transcriptions", {
+                // Provide placeholder body for type checking; actual payload comes from bodySerializer
+                body: { file: "", model },
+                bodySerializer: () => formData,
+            });
+            const result = data;
+            const parts = [];
+            parts.push({ type: "text", text: result.text });
+            if (result.language) {
+                parts.push({
+                    type: "text",
+                    text: `[Language: ${result.language}]`,
+                });
+            }
+            if (result.duration !== undefined) {
+                parts.push({
+                    type: "text",
+                    text: `[Duration: ${result.duration}s]`,
+                });
+            }
+            return { content: parts };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=transcription.js.map

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@manfred-kunze-dev/backbone-mcp-server",
+  "version": "2.6.0-dev.4",
+  "description": "MCP server for the Backbone AI platform",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "backbone-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "inspect": "npx @modelcontextprotocol/inspector -- node dist/index.js",
+    "generate:spec": "tsx --env-file=.env openapi/scripts/fetch-spec.ts",
+    "generate:types": "openapi-typescript openapi/openapi.json -o src/generated/openapi.d.ts",
+    "generate": "npm run generate:spec && npm run generate:types",
+    "check:spec": "tsx --env-file=.env openapi/scripts/check-drift.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.0",
+    "openapi-fetch": "^0.13.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.4",
+    "openapi-typescript": "^7.6.1",
+    "tsx": "^4.19.3",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18.20.8"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/manfred-kunze-dev/backbone.git",
+    "directory": "mcp"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ]
+}