@kitsra/kavio-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,94 @@
+Elastic License 2.0
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other
+notices of the licensor in the software. Any use of the licensor's trademarks
+is subject to applicable law.
+
+Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software.
+
+If you or your company make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license for the software
+granted under these terms ends immediately. If your company makes such a claim,
+your patent license ends immediately for work on behalf of your company.
+
+Notices
+
+You must ensure that anyone who gets a copy of any part of the software from
+you also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+No Liability
+
+As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.
+
+Definitions
+
+The licensor is the entity offering these terms, and the software is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+you refers to the individual or entity agreeing to these terms.
+
+your company is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that organization.
+control means ownership of substantially all the assets of an entity, or the
+power to direct its management and policies by vote, contract, or otherwise.
+Control can be direct or indirect.
+
+your licenses are all the licenses granted to you for the software under these
+terms.
+
+use means anything you do with the software requiring one of your licenses.
+
+trademark means trademarks, service marks, and similar rights.

package/dist/adapters/anthropic.d.ts

@@ -0,0 +1,9 @@
+import type { JsonSchema, ToolDefinition } from "../types.js";
+export interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: JsonSchema;
+}
+/** Convert the catalog tools to Anthropic tool-use definitions. */
+export declare function toAnthropicTools(tools: readonly ToolDefinition[]): AnthropicTool[];
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/adapters/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../src/adapters/anthropic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE9D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,UAAU,CAAC;CAC1B;AAED,mEAAmE;AACnE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,aAAa,EAAE,CAMlF"}

package/dist/adapters/anthropic.js

@@ -0,0 +1,8 @@
+/** Convert the catalog tools to Anthropic tool-use definitions. */
+export function toAnthropicTools(tools) {
+    return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.inputSchema
+    }));
+}

package/dist/adapters/gemini.d.ts

@@ -0,0 +1,12 @@
+import type { JsonSchema, ToolDefinition } from "../types.js";
+export interface GeminiFunctionDeclaration {
+    name: string;
+    description: string;
+    parameters: JsonSchema;
+}
+export interface GeminiTool {
+    functionDeclarations: GeminiFunctionDeclaration[];
+}
+/** Convert the catalog tools to Gemini function declarations (schema sanitized). */
+export declare function toGeminiTools(tools: readonly ToolDefinition[]): GeminiTool[];
+//# sourceMappingURL=gemini.d.ts.map

package/dist/adapters/gemini.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../src/adapters/gemini.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG9D,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACzB,oBAAoB,EAAE,yBAAyB,EAAE,CAAC;CACnD;AAED,oFAAoF;AACpF,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,UAAU,EAAE,CAU5E"}

package/dist/adapters/gemini.js

@@ -0,0 +1,13 @@
+import { stripForGemini } from "./sanitize.js";
+/** Convert the catalog tools to Gemini function declarations (schema sanitized). */
+export function toGeminiTools(tools) {
+    return [
+        {
+            functionDeclarations: tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                parameters: stripForGemini(tool.inputSchema)
+            }))
+        }
+    ];
+}

package/dist/adapters/openai.d.ts

@@ -0,0 +1,12 @@
+import type { JsonSchema, ToolDefinition } from "../types.js";
+export interface OpenAITool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: JsonSchema;
+    };
+}
+/** Convert the catalog tools to OpenAI function-calling definitions. */
+export declare function toOpenAITools(tools: readonly ToolDefinition[]): OpenAITool[];
+//# sourceMappingURL=openai.d.ts.map

package/dist/adapters/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../src/adapters/openai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE9D,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,UAAU,CAAC;KACxB,CAAC;CACH;AAED,wEAAwE;AACxE,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,UAAU,EAAE,CAS5E"}

package/dist/adapters/openai.js

@@ -0,0 +1,11 @@
+/** Convert the catalog tools to OpenAI function-calling definitions. */
+export function toOpenAITools(tools) {
+    return tools.map((tool) => ({
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.inputSchema
+        }
+    }));
+}

package/dist/adapters/sanitize.d.ts

@@ -0,0 +1,4 @@
+import type { JsonSchema } from "../types.js";
+/** Strip JSON Schema keys that Gemini's function-declaration subset rejects. */
+export declare function stripForGemini(schema: JsonSchema): JsonSchema;
+//# sourceMappingURL=sanitize.d.ts.map

package/dist/adapters/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/adapters/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9C,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAE7D"}

package/dist/adapters/sanitize.js

@@ -0,0 +1,21 @@
+const GEMINI_UNSUPPORTED_KEYS = new Set(["$schema", "$id", "additionalProperties"]);
+/** Strip JSON Schema keys that Gemini's function-declaration subset rejects. */
+export function stripForGemini(schema) {
+    return strip(schema);
+}
+function strip(value) {
+    if (Array.isArray(value)) {
+        return value.map(strip);
+    }
+    if (value !== null && typeof value === "object") {
+        const output = {};
+        for (const [key, nested] of Object.entries(value)) {
+            if (GEMINI_UNSUPPORTED_KEYS.has(key)) {
+                continue;
+            }
+            output[key] = strip(nested);
+        }
+        return output;
+    }
+    return value;
+}

package/dist/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":""}

package/dist/bin.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { mkdir, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { toAnthropicTools } from "./adapters/anthropic.js";
+import { toGeminiTools } from "./adapters/gemini.js";
+import { toOpenAITools } from "./adapters/openai.js";
+import { createCatalog } from "./catalog.js";
+import { createServer } from "./server.js";
+async function emitAdapters(outDir) {
+    const tools = createCatalog().tools;
+    await mkdir(outDir, { recursive: true });
+    await writeFile(resolve(outDir, "anthropic.tools.json"), `${JSON.stringify(toAnthropicTools(tools), null, 2)}\n`);
+    await writeFile(resolve(outDir, "openai.tools.json"), `${JSON.stringify(toOpenAITools(tools), null, 2)}\n`);
+    await writeFile(resolve(outDir, "gemini.tools.json"), `${JSON.stringify(toGeminiTools(tools), null, 2)}\n`);
+}
+async function serve() {
+    const server = createServer(createCatalog());
+    await server.connect(new StdioServerTransport());
+}
+async function main(argv) {
+    if (argv[2] === "emit-adapters") {
+        const flagIndex = argv.indexOf("--out");
+        const outDir = flagIndex >= 0 ? argv[flagIndex + 1] : undefined;
+        if (outDir === undefined || outDir.length === 0) {
+            process.stderr.write("Usage: kavio-mcp emit-adapters --out <dir>\n");
+            process.exitCode = 1;
+            return;
+        }
+        await emitAdapters(outDir);
+        process.stdout.write(`Wrote anthropic/openai/gemini tool files to ${outDir}\n`);
+        return;
+    }
+    await serve();
+}
+void main(process.argv).catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/catalog.d.ts

@@ -0,0 +1,8 @@
+import { type RenderHandlerDeps } from "./handlers.js";
+import type { Catalog } from "./types.js";
+export interface CreateCatalogOptions {
+    render?: RenderHandlerDeps;
+}
+/** Build the Kavio tool/resource/prompt catalog (the single source of truth). */
+export declare function createCatalog(options?: CreateCatalogOptions): Catalog;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,iBAAiB,EACvB,MAAM,eAAe,CAAC;AAGvB,OAAO,KAAK,EAAE,OAAO,EAA8B,MAAM,YAAY,CAAC;AAEtE,MAAM,WAAW,oBAAoB;IACnC,MAAM,CAAC,EAAE,iBAAiB,CAAC;CAC5B;AA4BD,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAkDzE"}

package/dist/catalog.js

@@ -0,0 +1,75 @@
+import { inspectComposition, listExportPresets, migrateComposition, planRender, renderHandler, resolveProps, validateComposition } from "./handlers.js";
+import { prompts } from "./prompts.js";
+import { resources } from "./resources.js";
+const documentSchema = { type: "object", description: "A Kavio composition document." };
+function documentInput(extra = {}) {
+    return {
+        type: "object",
+        properties: { document: documentSchema, ...extra },
+        required: ["document"],
+        additionalProperties: false
+    };
+}
+function batchInput(extra = {}) {
+    return {
+        type: "object",
+        properties: {
+            document: documentSchema,
+            props: { type: "object", description: "Prop values for a single render." },
+            presets: { type: "array", items: { type: "string" }, description: "Export preset names." },
+            rows: { type: "array", description: "Batch prop rows: [{ id?, props? }]." },
+            ...extra
+        },
+        required: ["document"],
+        additionalProperties: false
+    };
+}
+/** Build the Kavio tool/resource/prompt catalog (the single source of truth). */
+export function createCatalog(options = {}) {
+    const renderDeps = options.render ?? {};
+    const tools = [
+        {
+            name: "validate_composition",
+            description: "Validate a Kavio composition; returns path-keyed errors for repair.",
+            inputSchema: documentInput(),
+            handler: validateComposition
+        },
+        {
+            name: "inspect_composition",
+            description: "Summarize a composition: dimensions, fps, duration, counts, and transition overlap windows.",
+            inputSchema: documentInput(),
+            handler: inspectComposition
+        },
+        {
+            name: "migrate_composition",
+            description: "Migrate a composition to the latest Kavio schema version.",
+            inputSchema: documentInput(),
+            handler: migrateComposition
+        },
+        {
+            name: "resolve_props",
+            description: "Resolve {{prop}} placeholders in a composition using the given prop values.",
+            inputSchema: documentInput({ props: { type: "object", description: "Prop values." } }),
+            handler: resolveProps
+        },
+        {
+            name: "list_export_presets",
+            description: "List the standard Kavio social export presets shared with the builder SDK.",
+            inputSchema: { type: "object", properties: {}, additionalProperties: false },
+            handler: listExportPresets
+        },
+        {
+            name: "plan_render",
+            description: "Expand template x rows x presets and assemble the FFmpeg command(s) without rendering. Always available.",
+            inputSchema: batchInput(),
+            handler: planRender
+        },
+        {
+            name: "render",
+            description: "Render a composition to MP4 (browser capture + FFmpeg). Returns a BINARY_MISSING error if Chromium/FFmpeg are unavailable.",
+            inputSchema: batchInput({ outDir: { type: "string", description: "Output directory (default: renders)." } }),
+            handler: (input) => renderHandler(input, renderDeps)
+        }
+    ];
+    return { tools, resources, prompts };
+}

package/dist/handlers.d.ts

@@ -0,0 +1,16 @@
+import { type FfmpegRunner } from "@kitsra/kavio-render";
+import { type BrowserDriver } from "@kitsra/kavio-render-worker";
+import type { ToolResult } from "./types.js";
+export declare const STANDARD_PRESETS: readonly [import("@kitsra/kavio-builder").SocialMediaPresetDefinition, import("@kitsra/kavio-builder").SocialMediaPresetDefinition, import("@kitsra/kavio-builder").SocialMediaPresetDefinition, import("@kitsra/kavio-builder").SocialMediaPresetDefinition, import("@kitsra/kavio-builder").SocialMediaPresetDefinition, import("@kitsra/kavio-builder").SocialMediaPresetDefinition, import("@kitsra/kavio-builder").SocialMediaPresetDefinition];
+export declare function validateComposition(input: unknown): ToolResult;
+export declare function inspectComposition(input: unknown): ToolResult;
+export declare function migrateComposition(input: unknown): ToolResult;
+export declare function resolveProps(input: unknown): ToolResult;
+export declare function listExportPresets(_input: unknown): ToolResult;
+export declare function planRender(input: unknown): ToolResult;
+export interface RenderHandlerDeps {
+    driver?: BrowserDriver;
+    ffmpegRunner?: FfmpegRunner;
+}
+export declare function renderHandler(input: unknown, deps?: RenderHandlerDeps): Promise<ToolResult>;
+//# sourceMappingURL=handlers.d.ts.map

package/dist/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../src/handlers.ts"],"names":[],"mappings":"AASA,OAAO,EAAsC,KAAK,YAAY,EAA2B,MAAM,sBAAsB,CAAC;AACtH,OAAO,EAAqB,KAAK,aAAa,EAA8C,MAAM,6BAA6B,CAAC;AAEhI,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,gBAAgB,sbAAqB,CAAC;AAEnD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAU9D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAiD7D;AAmFD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAgB7D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAWvD;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,GAAG,UAAU,CAE7D;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAsCrD;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED,wBAAsB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,iBAAsB,GAAG,OAAO,CAAC,UAAU,CAAC,CAoCrG"}

package/dist/handlers.js

@@ -0,0 +1,275 @@
+import { isAbsolute, relative, resolve } from "node:path";
+import { applyExportPreset, collectCompositionResourceLimitInputs, collectResourceLimitViolations, compileTransitionOverlapWindows, resolveTemplateProps } from "@kitsra/kavio-core";
+import { socialMediaPresets } from "@kitsra/kavio-builder";
+import { assembleRenderCommand, renderBatch } from "@kitsra/kavio-render";
+import { expandRenderBatch } from "@kitsra/kavio-render-worker";
+import { schemaVersion, validateComposition as schemaValidate } from "@kitsra/kavio-schema";
+export const STANDARD_PRESETS = socialMediaPresets;
+export function validateComposition(input) {
+    const document = readDocument(input);
+    if (document.ok === false) {
+        return document.result;
+    }
+    const result = schemaValidate(document.value);
+    if (result.ok) {
+        return { ok: true, data: { ok: true, errors: [] } };
+    }
+    return { ok: false, errors: result.errors };
+}
+export function inspectComposition(input) {
+    const document = readDocument(input);
+    if (document.ok === false) {
+        return document.result;
+    }
+    const validation = schemaValidate(document.value);
+    if (!validation.ok) {
+        return { ok: false, errors: validation.errors };
+    }
+    const doc = document.value;
+    const fps = Number(doc.composition.fps);
+    return {
+        ok: true,
+        data: {
+            version: doc.version,
+            composition: {
+                width: doc.composition.width,
+                height: doc.composition.height,
+                fps,
+                durationFrames: doc.composition.durationFrames,
+                durationSeconds: fps > 0 ? doc.composition.durationFrames / fps : 0
+            },
+            props: { count: doc.props === undefined ? 0 : Object.keys(doc.props).length },
+            assets: { count: Object.keys(doc.assets).length, types: countTypes(Object.values(doc.assets)) },
+            layers: { count: doc.layers.length, types: countTypes(doc.layers) },
+            masks: inspectMasks(doc),
+            tracks: {
+                count: doc.tracks === undefined ? 0 : doc.tracks.length,
+                clipCount: doc.tracks === undefined ? 0 : doc.tracks.reduce((total, track) => total + track.clips.length, 0),
+                transitionWindows: compileTransitionOverlapWindows(doc.tracks).map((window) => ({
+                    trackId: window.trackId,
+                    previousClipId: window.previousClipId,
+                    previousLayerId: window.previousLayerId,
+                    nextClipId: window.nextClipId,
+                    nextLayerId: window.nextLayerId,
+                    startFrame: window.startFrame,
+                    endFrame: window.endFrame,
+                    durationFrames: window.durationFrames,
+                    transitionType: window.transition.type
+                }))
+            },
+            audio: { count: doc.audio === undefined ? 0 : doc.audio.length },
+            exports: {
+                count: doc.exports.length,
+                names: doc.exports.map((entry, index) => (typeof entry.name === "string" ? entry.name : `export-${index + 1}`))
+            }
+        }
+    };
+}
+function inspectMasks(document) {
+    const summary = {
+        count: 0,
+        shapeCount: 0,
+        assetMasks: [],
+        proceduralMasks: [],
+        invertedCount: 0
+    };
+    for (const layer of document.layers) {
+        const mask = layer.mask;
+        if (!mask) {
+            continue;
+        }
+        summary.count += 1;
+        if (mask.invert === true) {
+            summary.invertedCount += 1;
+        }
+        switch (mask.source.kind) {
+            case "shape":
+                summary.shapeCount += 1;
+                break;
+            case "asset":
+                summary.assetMasks.push(withResolution({
+                    layerId: layer.id,
+                    asset: mask.source.asset,
+                    mode: mask.source.mode ?? "alpha"
+                }, mask.source.resolution));
+                break;
+            case "procedural":
+                summary.proceduralMasks.push(withResolution({
+                    layerId: layer.id,
+                    type: mask.source.type,
+                    seed: mask.source.seed,
+                    ...(mask.source.direction === undefined ? {} : { direction: mask.source.direction })
+                }, mask.source.resolution));
+                break;
+        }
+    }
+    return summary;
+}
+function withResolution(value, resolution) {
+    return (resolution === undefined
+        ? value
+        : {
+            ...value,
+            width: resolution.width,
+            height: resolution.height
+        });
+}
+export function migrateComposition(input) {
+    const document = readDocument(input);
+    if (document.ok === false) {
+        return document.result;
+    }
+    const version = document.value.version;
+    if (typeof version !== "string") {
+        return { ok: false, errors: [mcpError("Document is missing a string version.")] };
+    }
+    if (version !== schemaVersion) {
+        return {
+            ok: false,
+            errors: [mcpError(`No migration path from ${version} to ${schemaVersion}.`, "MCP_MIGRATION_UNSUPPORTED")]
+        };
+    }
+    return { ok: true, data: { changed: false, fromVersion: version, toVersion: schemaVersion, document: document.value } };
+}
+export function resolveProps(input) {
+    if (!isRecord(input) || !("document" in input)) {
+        return { ok: false, errors: [mcpError("Expected { document, props } input.")] };
+    }
+    const props = input.props;
+    const values = isRecord(props) ? props : {};
+    const resolution = resolveTemplateProps(input.document, values);
+    if (resolution.ok) {
+        return { ok: true, data: resolution.value };
+    }
+    return { ok: false, errors: resolution.errors };
+}
+export function listExportPresets(_input) {
+    return { ok: true, data: STANDARD_PRESETS.map((preset) => ({ ...preset, preset: { ...preset.preset } })) };
+}
+export function planRender(input) {
+    const parsed = parseBatchInput(input);
+    if (parsed.ok === false) {
+        return { ok: false, errors: [parsed.error] };
+    }
+    const jobs = [];
+    let expanded;
+    try {
+        expanded = expandRenderBatch(parsed.batchInput);
+    }
+    catch (error) {
+        return { ok: false, errors: toErrors(error, "MCP_PLAN_FAILED") };
+    }
+    for (const job of expanded) {
+        const resolution = resolveTemplateProps(job.document, job.props);
+        if (!resolution.ok) {
+            return { ok: false, errors: resolution.errors };
+        }
+        try {
+            const view = applyExportPreset(resolution.value, job.preset);
+            const violations = collectResourceLimitViolations(collectCompositionResourceLimitInputs(view));
+            if (violations.length > 0) {
+                return { ok: false, errors: violations };
+            }
+            const ffmpegArgs = assembleRenderCommand({
+                view,
+                preset: job.preset,
+                framePattern: "overlay-%05d.png",
+                outputPath: job.outputName
+            });
+            jobs.push({ id: job.id, outputName: job.outputName, preset: job.preset, ffmpegArgs });
+        }
+        catch (error) {
+            return { ok: false, errors: toErrors(error, "MCP_PLAN_FAILED") };
+        }
+    }
+    return { ok: true, data: { jobs } };
+}
+export async function renderHandler(input, deps = {}) {
+    const parsed = parseBatchInput(input);
+    if (parsed.ok === false) {
+        return { ok: false, errors: [parsed.error] };
+    }
+    const outDir = safeRenderOutDir(isRecord(input) ? input.outDir : undefined);
+    if (outDir.ok === false) {
+        return { ok: false, errors: [outDir.error] };
+    }
+    const options = { outDir: outDir.value };
+    if (deps.driver !== undefined) {
+        options.driver = deps.driver;
+    }
+    if (deps.ffmpegRunner !== undefined) {
+        options.ffmpegRunner = deps.ffmpegRunner;
+    }
+    let results;
+    try {
+        results = await renderBatch(parsed.batchInput, options);
+    }
+    catch (error) {
+        return { ok: false, errors: toErrors(error, "RENDER_FAILED") };
+    }
+    const outputs = results.map((item) => item.result.ok
+        ? { id: item.id, outputName: item.outputName, ok: true, outputPath: item.result.outputPath, metadata: item.result.metadata }
+        : { id: item.id, outputName: item.outputName, ok: false, errors: item.result.errors });
+    const allOk = results.length > 0 && results.every((item) => item.result.ok);
+    if (allOk) {
+        return { ok: true, data: { outputs } };
+    }
+    const failures = results.flatMap((item) => (item.result.ok ? [] : item.result.errors));
+    return { ok: false, data: { outputs }, errors: failures };
+}
+function readDocument(input) {
+    if (!isRecord(input) || !("document" in input)) {
+        return { ok: false, result: { ok: false, errors: [mcpError("Expected { document } input.")] } };
+    }
+    return { ok: true, value: input.document };
+}
+function parseBatchInput(input) {
+    if (!isRecord(input) || !("document" in input)) {
+        return { ok: false, error: mcpError("Expected { document } input.") };
+    }
+    const document = input.document;
+    const rowsInput = input.rows;
+    const presetsInput = input.presets;
+    const propsInput = input.props;
+    const rows = Array.isArray(rowsInput)
+        ? rowsInput
+        : [{ props: (isRecord(propsInput) ? propsInput : {}) }];
+    const batchInput = { template: document, rows };
+    if (Array.isArray(presetsInput)) {
+        batchInput.presets = presetsInput;
+    }
+    return { ok: true, batchInput };
+}
+function safeRenderOutDir(input) {
+    const base = resolve("renders");
+    const requested = typeof input === "string" && input.length > 0 ? input : ".";
+    const outDir = resolve(base, requested);
+    const relativePath = relative(base, outDir);
+    if (relativePath === ".." || relativePath.startsWith("../") || isAbsolute(relativePath)) {
+        return {
+            ok: false,
+            error: mcpError("outDir must stay inside the renders directory.", "MCP_INPUT_INVALID")
+        };
+    }
+    return { ok: true, value: outDir };
+}
+function countTypes(items) {
+    const counts = {};
+    for (const item of items) {
+        const type = isRecord(item) && typeof item.type === "string" ? item.type : "unknown";
+        counts[type] = (counts[type] ?? 0) + 1;
+    }
+    return counts;
+}
+function mcpError(message, code = "MCP_INPUT_INVALID") {
+    return { code, severity: "error", message, path: "", stage: "validation", retryable: false };
+}
+function toErrors(error, fallbackCode) {
+    if (isRecord(error) && typeof error.code === "string" && typeof error.stage === "string") {
+        return [error];
+    }
+    return [mcpError(error instanceof Error ? error.message : String(error), fallbackCode)];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export declare const KAVIO_MCP_PACKAGE = "@kitsra/kavio-mcp";
+export { createCatalog, type CreateCatalogOptions } from "./catalog.js";
+export type { Catalog, JsonSchema, PromptArgument, PromptDefinition, ResourceDefinition, ToolDefinition, ToolResult } from "./types.js";
+export { toAnthropicTools, type AnthropicTool } from "./adapters/anthropic.js";
+export { toOpenAITools, type OpenAITool } from "./adapters/openai.js";
+export { toGeminiTools, type GeminiFunctionDeclaration, type GeminiTool } from "./adapters/gemini.js";
+export { stripForGemini } from "./adapters/sanitize.js";
+export { resources } from "./resources.js";
+export { prompts } from "./prompts.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,sBAAsB,CAAC;AAErD,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACxE,YAAY,EACV,OAAO,EACP,UAAU,EACV,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,UAAU,EACX,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,KAAK,yBAAyB,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACtG,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+export const KAVIO_MCP_PACKAGE = "@kitsra/kavio-mcp";
+export { createCatalog } from "./catalog.js";
+export { toAnthropicTools } from "./adapters/anthropic.js";
+export { toOpenAITools } from "./adapters/openai.js";
+export { toGeminiTools } from "./adapters/gemini.js";
+export { stripForGemini } from "./adapters/sanitize.js";
+export { resources } from "./resources.js";
+export { prompts } from "./prompts.js";
+// Note: server.ts / bin.ts are intentionally NOT re-exported here so that
+// library consumers that only want the catalog or adapters do not pull in the
+// MCP SDK. The server is reached via the `kavio-mcp` bin.

package/dist/prompts.d.ts

@@ -0,0 +1,3 @@
+import type { PromptDefinition } from "./types.js";
+export declare const prompts: PromptDefinition[];
+//# sourceMappingURL=prompts.d.ts.map

package/dist/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../src/prompts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,eAAO,MAAM,OAAO,EAAE,gBAAgB,EAgErC,CAAC"}

package/dist/prompts.js

@@ -0,0 +1,62 @@
+export const prompts = [
+    {
+        name: "author_kavio_video",
+        description: "Generate a Kavio video composition (JSON) from a natural-language brief.",
+        arguments: [
+            { name: "brief", description: "What the video should contain", required: true },
+            { name: "width", description: "Canvas width in px (default 1080)", required: false },
+            { name: "height", description: "Canvas height in px (default 1920)", required: false },
+            { name: "durationSeconds", description: "Duration in seconds (default 10)", required: false }
+        ],
+        render: (args) => [
+            "You are authoring a Kavio video composition as JSON.",
+            "",
+            `Brief: ${args.brief}`,
+            `Canvas: ${args.width ?? "1080"}x${args.height ?? "1920"}, duration ${args.durationSeconds ?? "10"}s @ 30fps.`,
+            "",
+            "Rules:",
+            "- Follow the schema resource `kavio://schema/0.1.json` exactly; use only allowed enum values (`kavio://enums.json`).",
+            "- Use `kavio://examples/basic.json` as a structural reference.",
+            "- Time is in integer frames; positions in composition pixels; anchor defaults to top-left.",
+            "- Emit ONLY valid Kavio JSON, no prose.",
+            "",
+            "Then call `validate_composition`. If it returns errors, fix the exact JSON paths and re-validate until it passes."
+        ].join("\n")
+    },
+    {
+        name: "repair_kavio_json",
+        description: "Repair a Kavio composition using structured validation errors.",
+        arguments: [
+            { name: "document", description: "The invalid Kavio JSON", required: true },
+            { name: "errors", description: "The errors array returned by validate_composition (JSON)", required: true }
+        ],
+        render: (args) => [
+            "The following Kavio composition failed validation.",
+            "",
+            "Document:",
+            args.document,
+            "",
+            "Errors (each has a JSON `path`):",
+            args.errors,
+            "",
+            "Fix ONLY the fields at the listed paths. Do not restructure anything else.",
+            "Return the corrected full Kavio JSON, then call `validate_composition` again to confirm."
+        ].join("\n")
+    },
+    {
+        name: "adapt_for_platform",
+        description: "Adapt a Kavio composition to a platform export preset.",
+        arguments: [
+            { name: "document", description: "The Kavio JSON to adapt", required: true },
+            { name: "platform", description: "Target preset: reels | square | landscape", required: true }
+        ],
+        render: (args) => [
+            `Adapt this Kavio composition for the "${args.platform}" platform preset (see \`kavio://presets.json\`).`,
+            "Set the export to the target dimensions and adjust layer positions / safe areas so the layout fits the new aspect ratio.",
+            "Prefer per-export layerOverrides over editing shared layers where possible.",
+            "",
+            "Document:",
+            args.document
+        ].join("\n")
+    }
+];

package/dist/resources.d.ts

@@ -0,0 +1,3 @@
+import type { ResourceDefinition } from "./types.js";
+export declare const resources: ResourceDefinition[];
+//# sourceMappingURL=resources.d.ts.map

package/dist/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../src/resources.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAgPrD,eAAO,MAAM,SAAS,EAAE,kBAAkB,EAoCzC,CAAC"}

package/dist/resources.js

@@ -0,0 +1,267 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { DEFAULT_RESOURCE_LIMITS } from "@kitsra/kavio-core";
+import { STANDARD_PRESETS } from "./handlers.js";
+const require = createRequire(import.meta.url);
+function readSchema() {
+    return readFileSync(require.resolve("@kitsra/kavio-schema/schema"), "utf8");
+}
+const BASIC_EXAMPLE = {
+    version: "0.1",
+    composition: { width: 1080, height: 1920, fps: 30, durationFrames: 90, background: "#101820" },
+    props: {
+        headline: { type: "string", default: "Your headline" }
+    },
+    assets: {},
+    layers: [
+        { id: "bg", type: "shape", shape: "rect", fill: "#101820", startFrame: 0, durationFrames: 90 },
+        {
+            id: "headline",
+            type: "text",
+            text: "{{headline}}",
+            startFrame: 6,
+            durationFrames: 78,
+            position: { x: 540, y: 860 },
+            anchor: "center",
+            style: { fontFamily: "Inter", fontSize: 72, fontWeight: 800, color: "#FFFFFF", align: "center" },
+            keyframes: {
+                opacity: [
+                    { frame: 0, value: 0 },
+                    { frame: 12, value: 1, easing: "outCubic" }
+                ]
+            }
+        }
+    ],
+    audio: [],
+    exports: [{ name: "reels", format: "mp4", codec: "h264", width: 1080, height: 1920 }]
+};
+const ENUMS = {
+    layerType: ["video", "image", "text", "shape", "caption"],
+    assetType: ["video", "image", "audio", "font"],
+    fit: ["cover", "contain", "fill", "none"],
+    anchor: ["top-left", "top", "top-right", "left", "center", "right", "bottom-left", "bottom", "bottom-right"],
+    easing: [
+        "linear",
+        "inQuad",
+        "outQuad",
+        "inOutQuad",
+        "inCubic",
+        "outCubic",
+        "inOutCubic",
+        "inCirc",
+        "outCirc",
+        "inOutCirc",
+        "inExpo",
+        "outExpo",
+        "inOutExpo",
+        "anticipate",
+        "back",
+        "inBack",
+        "outBack",
+        "inOutBack",
+        "inElastic",
+        "outElastic",
+        "inOutElastic",
+        "inBounce",
+        "outBounce",
+        "inOutBounce"
+    ],
+    timing: ["tween", "spring", "steps", "sequence", "stagger"],
+    preset: ["fadeIn", "fadeOut", "slideUp", "slideDown", "slideLeft", "slideRight", "popIn", "zoomIn"],
+    presetNamespace: ["transition", "cinematic", "textMotion", "camera", "effect"],
+    effect: ["blur", "brightness", "contrast", "saturate", "tint"],
+    transitionTiming: ["tween"],
+    maskSourceKind: ["shape", "asset", "procedural"],
+    maskShape: ["rect", "circle", "diamond"],
+    proceduralMask: ["linearGradient", "radialGradient", "scanlines"],
+    maskAssetMode: ["alpha"],
+    transition: [
+        "fade",
+        "slide",
+        "wipe",
+        "crossfade",
+        "zoom",
+        "push",
+        "spin",
+        "rotate",
+        "flip",
+        "blurDissolve",
+        "colorDissolve",
+        "dip",
+        "iris",
+        "stretch",
+        "squeeze",
+        "clockWipe",
+        "barWipe",
+        "gridWipe",
+        "tileReveal",
+        "radialBlur",
+        "zoomBlur",
+        "bookFlip",
+        "pageCurlLite",
+        "skewSlide",
+        "expandMask",
+        "letterboxReveal",
+        "filmFlash",
+        "cameraWhip"
+    ],
+    cameraMotion: ["kenBurns", "pushIn", "pullBack", "pan", "tilt"],
+    audioRole: ["music", "voiceover", "sfx", "source"],
+    exportFormat: ["mp4", "webm", "mov", "gif", "png-sequence"],
+    propType: ["string", "number", "boolean", "color", "url", "enum", "asset"]
+};
+const CURRENT_TRANSITION_SUPPORT = Object.fromEntries(ENUMS.transition.map((transition) => [
+    transition,
+    {
+        browserPreview: "stable",
+        stillFrameRender: "stable",
+        opaqueVideoRender: "stable",
+        transparentVideoRender: "unsupported",
+        gifRender: "unsupported",
+        pngSequenceRender: "unsupported",
+        nativeRender: "unsupported"
+    }
+]));
+const CURRENT_EFFECT_SUPPORT = Object.fromEntries(ENUMS.effect.map((effect) => [
+    effect,
+    {
+        browserPreview: "unsupported",
+        stillFrameRender: "unsupported",
+        opaqueVideoRender: "unsupported",
+        transparentVideoRender: "unsupported",
+        gifRender: "unsupported",
+        pngSequenceRender: "unsupported",
+        nativeRender: "unsupported",
+        note: "Schema-declared layer effects are not applied by the current evaluator or browser renderer."
+    }
+]));
+const MASK_SOURCE_SUPPORT = {
+    shape: {
+        stable: ["rect", "circle", "diamond"],
+        experimental: ["bar", "grid", "tiles"],
+        unsupported: [],
+        browserPreview: "stable",
+        stillFrameRender: "stable",
+        opaqueVideoRender: "stable",
+        transparentVideoRender: "unsupported",
+        gifRender: "unsupported",
+        pngSequenceRender: "unsupported",
+        nativeRender: "unsupported"
+    },
+    asset: {
+        stable: ["image-alpha"],
+        experimental: ["image-luma"],
+        unsupported: ["video-luma"],
+        browserPreview: "stable",
+        stillFrameRender: "stable",
+        opaqueVideoRender: "stable",
+        transparentVideoRender: "unsupported",
+        gifRender: "unsupported",
+        pngSequenceRender: "unsupported",
+        nativeRender: "unsupported",
+        note: "Stable asset masks reference declared image assets and use alpha sampling only."
+    },
+    procedural: {
+        stable: ["linearGradient", "radialGradient", "scanlines"],
+        experimental: ["noise", "threshold", "dither"],
+        unsupported: ["liquid", "shaderImageReveal"],
+        browserPreview: "stable",
+        stillFrameRender: "stable",
+        opaqueVideoRender: "stable",
+        transparentVideoRender: "unsupported",
+        gifRender: "unsupported",
+        pngSequenceRender: "unsupported",
+        nativeRender: "unsupported",
+        note: "Stable procedural masks require an integer seed even when the current CSS rendering is simple."
+    },
+    generatedOverlay: {
+        stable: [],
+        experimental: [],
+        unsupported: ["filmFlash", "lightLeak", "filmBurn", "grain", "vignette", "chromaticOffset"],
+        browserPreview: "unsupported",
+        stillFrameRender: "unsupported",
+        opaqueVideoRender: "unsupported",
+        transparentVideoRender: "unsupported",
+        gifRender: "unsupported",
+        pngSequenceRender: "unsupported",
+        nativeRender: "unsupported",
+        note: "Generated overlays are reserved for future deterministic overlay/effect work and are not valid layer masks today."
+    }
+};
+const MOTION_SUPPORT = {
+    supportStates: ["stable", "previewOnly", "experimental", "unsupported"],
+    renderTargets: [
+        "browserPreview",
+        "stillFrameRender",
+        "opaqueVideoRender",
+        "transparentVideoRender",
+        "gifRender",
+        "pngSequenceRender",
+        "nativeRender"
+    ],
+    transitions: CURRENT_TRANSITION_SUPPORT,
+    transitionSeries: {
+        schema: "stable",
+        coreEvaluation: "stable",
+        cliInspect: "stable",
+        mcpInspect: "stable",
+        browserPreview: "stable",
+        stillFrameRender: "stable",
+        opaqueVideoRender: "stable",
+        transparentVideoRender: "unsupported",
+        gifRender: "unsupported",
+        pngSequenceRender: "unsupported",
+        nativeRender: "unsupported",
+        note: "Tracks compile to explicit overlap windows for outgoing and incoming clip evaluation; browser-backed preview and render paths share the same frame evaluator."
+    },
+    effects: CURRENT_EFFECT_SUPPORT,
+    masks: MASK_SOURCE_SUPPORT,
+    performanceBudgets: {
+        maxBlurRadius: DEFAULT_RESOURCE_LIMITS.maxBlurRadius,
+        maxFilteredLayers: DEFAULT_RESOURCE_LIMITS.maxFilteredLayers,
+        maxMaskedLayers: DEFAULT_RESOURCE_LIMITS.maxMaskedLayers,
+        maxMaskSourceWidth: DEFAULT_RESOURCE_LIMITS.maxMaskSourceWidth,
+        maxMaskSourceHeight: DEFAULT_RESOURCE_LIMITS.maxMaskSourceHeight,
+        maxTextMotionFragments: DEFAULT_RESOURCE_LIMITS.maxTextMotionFragments,
+        maxProceduralMaskPixels: DEFAULT_RESOURCE_LIMITS.maxProceduralMaskPixels,
+        maxTransitionDurationFrames: DEFAULT_RESOURCE_LIMITS.maxTransitionDurationFrames,
+        note: "Render planning uses these budgets after export preset expansion."
+    }
+};
+export const resources = [
+    {
+        uri: "kavio://schema/0.1.json",
+        name: "Kavio JSON Schema 0.1",
+        description: "The canonical JSON Schema for a Kavio composition — the generation contract.",
+        mimeType: "application/json",
+        read: readSchema
+    },
+    {
+        uri: "kavio://presets.json",
+        name: "Export presets",
+        description: "Standard social export presets shared with the Kavio builder SDK.",
+        mimeType: "application/json",
+        read: () => `${JSON.stringify(STANDARD_PRESETS, null, 2)}\n`
+    },
+    {
+        uri: "kavio://examples/basic.json",
+        name: "Basic example composition",
+        description: "A minimal valid Kavio composition with a background, animated headline, and an export.",
+        mimeType: "application/json",
+        read: () => `${JSON.stringify(BASIC_EXAMPLE, null, 2)}\n`
+    },
+    {
+        uri: "kavio://enums.json",
+        name: "Enum reference",
+        description: "Allowed values for layer/asset types, easings, timing types, effects, transitions, formats, and prop types.",
+        mimeType: "application/json",
+        read: () => `${JSON.stringify(ENUMS, null, 2)}\n`
+    },
+    {
+        uri: "kavio://motion-support.json",
+        name: "Motion support matrix",
+        description: "Current transition/effect support states by render target plus motion performance budgets.",
+        mimeType: "application/json",
+        read: () => `${JSON.stringify(MOTION_SUPPORT, null, 2)}\n`
+    }
+];

package/dist/server.d.ts

@@ -0,0 +1,10 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { Catalog } from "./types.js";
+/**
+ * Wire a Catalog to an MCP server using the SDK's low-level Server +
+ * setRequestHandler, so the catalog's raw JSON Schemas flow straight through
+ * (the high-level registerTool API is zod-centric and would break the shared
+ * source of truth used by the adapters).
+ */
+export declare function createServer(catalog: Catalog): Server;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAWnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CA6DrD"}

package/dist/server.js

@@ -0,0 +1,60 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ErrorCode, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, McpError, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Wire a Catalog to an MCP server using the SDK's low-level Server +
+ * setRequestHandler, so the catalog's raw JSON Schemas flow straight through
+ * (the high-level registerTool API is zod-centric and would break the shared
+ * source of truth used by the adapters).
+ */
+export function createServer(catalog) {
+    const server = new Server({ name: "kavio", version: "0.1.0" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, () => ({
+        tools: catalog.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema
+        }))
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const tool = catalog.tools.find((candidate) => candidate.name === request.params.name);
+        if (tool === undefined) {
+            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+        }
+        const result = await tool.handler(request.params.arguments ?? {});
+        return {
+            content: [{ type: "text", text: JSON.stringify(result.ok ? result.data : result.errors, null, 2) }],
+            isError: !result.ok
+        };
+    });
+    server.setRequestHandler(ListResourcesRequestSchema, () => ({
+        resources: catalog.resources.map((resource) => ({
+            uri: resource.uri,
+            name: resource.name,
+            description: resource.description,
+            mimeType: resource.mimeType
+        }))
+    }));
+    server.setRequestHandler(ReadResourceRequestSchema, (request) => {
+        const resource = catalog.resources.find((candidate) => candidate.uri === request.params.uri);
+        if (resource === undefined) {
+            throw new McpError(ErrorCode.InvalidParams, `Unknown resource: ${request.params.uri}`);
+        }
+        return { contents: [{ uri: resource.uri, mimeType: resource.mimeType, text: resource.read() }] };
+    });
+    server.setRequestHandler(ListPromptsRequestSchema, () => ({
+        prompts: catalog.prompts.map((prompt) => ({
+            name: prompt.name,
+            description: prompt.description,
+            arguments: prompt.arguments
+        }))
+    }));
+    server.setRequestHandler(GetPromptRequestSchema, (request) => {
+        const prompt = catalog.prompts.find((candidate) => candidate.name === request.params.name);
+        if (prompt === undefined) {
+            throw new McpError(ErrorCode.InvalidParams, `Unknown prompt: ${request.params.name}`);
+        }
+        const args = (request.params.arguments ?? {});
+        return { messages: [{ role: "user", content: { type: "text", text: prompt.render(args) } }] };
+    });
+    return server;
+}

package/dist/types.d.ts

@@ -0,0 +1,37 @@
+import type { KavioError } from "@kitsra/kavio-schema";
+export type JsonSchema = Record<string, unknown>;
+export interface ToolResult {
+    ok: boolean;
+    data?: unknown;
+    errors?: KavioError[];
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: JsonSchema;
+    handler: (input: unknown) => Promise<ToolResult> | ToolResult;
+}
+export interface ResourceDefinition {
+    uri: string;
+    name: string;
+    description: string;
+    mimeType: string;
+    read: () => string;
+}
+export interface PromptArgument {
+    name: string;
+    description: string;
+    required: boolean;
+}
+export interface PromptDefinition {
+    name: string;
+    description: string;
+    arguments: PromptArgument[];
+    render: (args: Record<string, string>) => string;
+}
+export interface Catalog {
+    tools: ToolDefinition[];
+    resources: ResourceDefinition[];
+    prompts: PromptDefinition[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,UAAU,CAAC;IACxB,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC;CAC/D;AAED,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;CAClD;AAED,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,SAAS,EAAE,kBAAkB,EAAE,CAAC;IAChC,OAAO,EAAE,gBAAgB,EAAE,CAAC;CAC7B"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@kitsra/kavio-mcp",
+  "version": "0.1.0",
+  "description": "Model Context Protocol server and provider tool adapters for Kavio.",
+  "license": "Elastic-2.0",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "kavio-mcp": "./dist/bin.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.0",
+    "@kitsra/kavio-render": "0.1.0",
+    "@kitsra/kavio-render-worker": "0.1.0",
+    "@kitsra/kavio-builder": "0.1.0",
+    "@kitsra/kavio-schema": "0.1.0",
+    "@kitsra/kavio-core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.tsbuildinfo"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "tsc -p tsconfig.json && node --test test/*.test.mjs"
+  }
+}