@mosvera/mcp 0.1.2 → 0.1.4

package/README.md

@@ -18,7 +18,7 @@ deterministic provider payloads that other tools can consume.
 
 The easiest path for non-command-line users is the Mosvera MCP Bundle:
 
-1. Download `mosvera-mcp-0.1.2.mcpb` from the latest
+1. Download `mosvera-mcp-0.1.4.mcpb` from the latest
    [GitHub release](https://github.com/mosvera/mcp/releases).
 2. Double-click the file, drag it into Claude Desktop, or install it from
    Claude Desktop Settings → Extensions → Advanced settings → Install
@@ -38,6 +38,21 @@ On first run, Mosvera seeds four public demo aesthetics into the registry:
 `quiet-editorial`, `technical-manual`, `cinematic-lab`, and
 `claymation-playful-builder`.
 
+## Language
+
+Mosvera uses a small term stack on purpose:
+
+- A **named aesthetic** is the user-facing intent, like
+  `executive-editorial`.
+- A **composition document** is the technical Mosvera document that resolves
+  that intent.
+- An **aesthetic pack** is a portable `.mosvera.json` file for sharing a named
+  aesthetic and its registry dependencies.
+- A **local registry** is the folder where your templates, palettes,
+  modifiers, composition documents, manifests, and merge strategies live.
+- **Tokens** and provider **payloads** are compiled outputs for other tools to
+  consume.
+
 ## Install With npm
 
 Use npm when you are wiring Mosvera into another MCP host or a developer
@@ -83,6 +98,14 @@ Resolve the claymation-playful-builder aesthetic and show me the canonical model
 Compile quiet-editorial into CSS variables.
 ```
 
+```text
+Export quiet-editorial as an aesthetic pack.
+```
+
+```text
+Preview importing this aesthetic pack into my registry.
+```
+
 ```text
 Save a new aesthetic called executive-editorial based on quiet-editorial-base with a more compact, board-ready voice.
 ```
@@ -102,6 +125,9 @@ flows.
 | `get_registry_document` | Read | Fetch a template, modifier, palette, composition, or capability manifest. |
 | `validate_document` | Read | Validate one document against a Mosvera schema kind. |
 | `validate_registry` | Read | Validate the active registry and return diagnostics. |
+| `validate_aesthetic_pack` | Read | Validate an inline or local `.mosvera.json` aesthetic pack. |
+| `preview_aesthetic_import` | Read | Preview importing an aesthetic pack without writing files. |
+| `export_aesthetic_pack` | Read | Export a named aesthetic as a portable `.mosvera.json` pack. |
 | `resolve_aesthetic` | Read | Resolve a named or inline aesthetic into canonical Mosvera JSON. |
 | `compile_design_tokens` | Read | Compile canonical output into portable design tokens and CSS variables. |
 | `compile_provider_payload` | Read | Advanced deterministic provider payload compilation; no provider HTTP call. |
@@ -110,6 +136,7 @@ flows.
 | `save_registry_document` | Write | Advanced create/update for registry documents and manifests. |
 | `delete_registry_document` | Destructive write | Delete a registry document. |
 | `write_merge_strategies` | Write | Replace `merge-strategies.json` with deterministic JSON. |
+| `import_aesthetic_pack` | Write | Import an aesthetic pack into the active local registry. |
 
 When the server starts with `--read-only`, write tools are not registered.
 
@@ -126,6 +153,11 @@ manifests/<provider>.manifest.json
 merge-strategies.json
 ```
 
+Aesthetic packs are exchanged as separate `.mosvera.json` files. They can carry
+templates, palettes, modifiers, composition documents, and merge strategies.
+They do not carry assets, provider manifests, credentials, remote URLs, or zip
+bundles in v1.
+
 IDs must be safe Mosvera references: lowercase letters, numbers, `_`, and `-`,
 starting with a letter. Absolute paths, dotfiles, path traversal, unknown
 kinds, and unsafe filenames are rejected.
@@ -144,7 +176,7 @@ npm run mcpb:inspect
 The MCPB pack step creates:
 
 ```text
-build/mosvera/mosvera-mcp-0.1.2.mcpb
+build/mosvera/mosvera-mcp-0.1.4.mcpb
 ```
 
 ## Package Boundaries

package/dist/context.d.ts

@@ -1,6 +1,6 @@
 import { type LoadedProject, type RegistryDiagnostic, type Validator } from "@mosvera/runtime";
 import type { ToolContext } from "./types.ts";
-export declare const SERVER_VERSION = "0.1.2";
+export declare const SERVER_VERSION = "0.1.4";
 export interface CliOptions {
     registryDir?: string;
     readOnlyMode: boolean;

package/dist/context.js

@@ -12,7 +12,7 @@ import { loadProject, RegistryProjectError } from "@mosvera/runtime/node";
 import { fluxAdapter } from "@mosvera/provider-flux";
 import { openaiAdapter } from "@mosvera/provider-openai";
 import { sdxlAdapter } from "@mosvera/provider-sdxl";
-export const SERVER_VERSION = "0.1.2";
+export const SERVER_VERSION = "0.1.4";
 function flagValue(argv, name) {
     const direct = argv.find((arg) => arg.startsWith(`${name}=`));
     if (direct !== undefined)

package/dist/server.js

@@ -10,8 +10,12 @@ import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import { buildContext, parseCliOptions, SERVER_VERSION } from "./context.js";
-import { documentKinds, runCompileDesignTokens, runCompileProviderPayload, runDeleteRegistryDocument, runDraftAesthetic, runGetRegistryDocument, runListAesthetics, runResolveAesthetic, runSaveAesthetic, runSaveRegistryDocument, runServerStatus, runValidateDocument, runValidateRegistry, runWriteMergeStrategies, } from "./tools/aesthetic.js";
+import { documentKinds, runCompileDesignTokens, runCompileProviderPayload, runDeleteRegistryDocument, runDraftAesthetic, runExportAestheticPack, runGetRegistryDocument, runImportAestheticPack, runListAesthetics, runPreviewAestheticImport, runResolveAesthetic, runSaveAesthetic, runSaveRegistryDocument, runServerStatus, runValidateAestheticPack, runValidateDocument, runValidateRegistry, runWriteMergeStrategies, } from "./tools/aesthetic.js";
 const docArg = z.union([z.string(), z.record(z.any())]);
+const packSourceArg = {
+    pack: docArg.optional(),
+    path: z.string().optional(),
+};
 const strategiesArg = z.record(z.object({
     strategy: z.enum(["replace", "append", "merge_by"]),
     key: z.string().optional(),
@@ -19,6 +23,8 @@ const strategiesArg = z.record(z.object({
 const criticalityArg = z.record(z.enum(["required", "optional"]));
 const documentKindArg = z.enum(documentKinds);
 const registryDocumentKindArg = z.enum(documentKinds);
+const packConflictArg = z.enum(["auto_rename", "fail", "replace"]);
+const packStrategyConflictArg = z.enum(["fail", "replace"]);
 const outputSchema = z.object({ ok: z.boolean(), message: z.string() }).passthrough();
 const readAnnotations = {
     readOnlyHint: true,
@@ -79,6 +85,36 @@ export function createServer(ctx) {
         outputSchema,
         annotations: readAnnotations,
     }, async () => runValidateRegistry(ctx));
+    server.registerTool("validate_aesthetic_pack", {
+        title: "Validate Aesthetic Pack",
+        description: "Validate an inline or local .mosvera.json aesthetic pack.",
+        inputSchema: packSourceArg,
+        outputSchema,
+        annotations: readAnnotations,
+    }, async (args) => runValidateAestheticPack(ctx, args));
+    server.registerTool("preview_aesthetic_import", {
+        title: "Preview Aesthetic Import",
+        description: "Preview importing an aesthetic pack into the active local registry without writing files.",
+        inputSchema: {
+            ...packSourceArg,
+            conflict_strategy: packConflictArg.optional(),
+            strategy_conflict: packStrategyConflictArg.optional(),
+        },
+        outputSchema,
+        annotations: readAnnotations,
+    }, async (args) => runPreviewAestheticImport(ctx, args));
+    server.registerTool("export_aesthetic_pack", {
+        title: "Export Aesthetic Pack",
+        description: "Export a named aesthetic and its registry dependencies as a portable .mosvera.json pack.",
+        inputSchema: {
+            aesthetic: z.string(),
+            id: z.string().optional(),
+            name: z.string().optional(),
+            description: z.string().optional(),
+        },
+        outputSchema,
+        annotations: readAnnotations,
+    }, async (args) => runExportAestheticPack(ctx, args));
     server.registerTool("resolve_aesthetic", {
         title: "Resolve Aesthetic",
         description: "Resolve a named or inline aesthetic composition into the canonical Mosvera model.",
@@ -157,6 +193,17 @@ export function createServer(ctx) {
             outputSchema,
             annotations: writeAnnotations,
         }, async (args) => runWriteMergeStrategies(ctx, args));
+        server.registerTool("import_aesthetic_pack", {
+            title: "Import Aesthetic Pack",
+            description: "Import an inline or local .mosvera.json aesthetic pack into the active local registry.",
+            inputSchema: {
+                ...packSourceArg,
+                conflict_strategy: packConflictArg.optional(),
+                strategy_conflict: packStrategyConflictArg.optional(),
+            },
+            outputSchema,
+            annotations: writeAnnotations,
+        }, async (args) => runImportAestheticPack(ctx, args));
     }
     return server;
 }

package/dist/tools/aesthetic.d.ts

@@ -1,4 +1,4 @@
-import { type Criticality, type DocumentKind, type MergeStrategies, type RegistryKind } from "@mosvera/runtime";
+import { type AestheticPackConflictStrategy, type AestheticPackStrategyConflict, type Criticality, type DocumentKind, type MergeStrategies, type RegistryKind } from "@mosvera/runtime";
 import type { ToolContext, ToolErrorCode } from "../types.ts";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 export declare const registryKinds: readonly ["template", "modifier", "palette", "composition"];
@@ -14,6 +14,22 @@ export declare function runValidateDocument(ctx: ToolContext, args: {
     kind: DocumentKind;
 }): CallToolResult;
 export declare function runValidateRegistry(ctx: ToolContext): CallToolResult;
+export declare function runValidateAestheticPack(ctx: ToolContext, args: {
+    pack?: object | string;
+    path?: string;
+}): CallToolResult;
+export declare function runPreviewAestheticImport(ctx: ToolContext, args: {
+    pack?: object | string;
+    path?: string;
+    conflict_strategy?: AestheticPackConflictStrategy;
+    strategy_conflict?: AestheticPackStrategyConflict;
+}): CallToolResult;
+export declare function runExportAestheticPack(ctx: ToolContext, args: {
+    aesthetic: string;
+    id?: string;
+    name?: string;
+    description?: string;
+}): CallToolResult;
 export declare function runResolveAesthetic(ctx: ToolContext, args: {
     aesthetic: string | object;
     merge_strategies?: MergeStrategies;
@@ -54,4 +70,10 @@ export declare function runDeleteRegistryDocument(ctx: ToolContext, args: {
 export declare function runWriteMergeStrategies(ctx: ToolContext, args: {
     merge_strategies: MergeStrategies;
 }): CallToolResult;
+export declare function runImportAestheticPack(ctx: ToolContext, args: {
+    pack?: object | string;
+    path?: string;
+    conflict_strategy?: AestheticPackConflictStrategy;
+    strategy_conflict?: AestheticPackStrategyConflict;
+}): CallToolResult;
 export declare function errorCodeFromResult(result: CallToolResult): ToolErrorCode | undefined;

package/dist/tools/aesthetic.js

@@ -3,15 +3,18 @@
 // User-facing Mosvera MCP tools. These handlers keep the MCP layer thin:
 // parse/validate inputs, call @mosvera/runtime, persist through the Node
 // boundary where needed, and return MCP-native structured results.
-import { compile, compileDesignTokens, composeStrategies, createComposition, getRegistryDocument, listRegistryEntries, parse, resolveAesthetic, toCssVariables, } from "@mosvera/runtime";
+import { compile, compileDesignTokens, composeStrategies, createComposition, exportAestheticPack, getRegistryDocument, importAestheticPack, listRegistryEntries, parse, previewAestheticPackImport, resolveAesthetic, toCssVariables, validateAestheticPack, } from "@mosvera/runtime";
 import { deleteProjectDocument, RegistryProjectError, saveProjectDocument, writeMergeStrategies } from "@mosvera/runtime/node";
 import { EmissionError } from "@mosvera/provider-base";
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
 import { registryDiagnostics, reloadContext, SERVER_VERSION } from "../context.js";
 import { fail, ok } from "../mcp-result.js";
 import { deleteCapabilityManifest, ProjectWriteError, saveCapabilityManifest } from "../project-writes.js";
 import { isResolutionError, mapResolutionError } from "../errors.js";
 export const registryKinds = ["template", "modifier", "palette", "composition"];
 export const documentKinds = ["template", "modifier", "palette", "composition", "capability-manifest"];
+const PACK_EXT = /\.mosvera\.json$/i;
 function parseDocument(source) {
     try {
         return parse(source);
@@ -23,6 +26,63 @@ function parseDocument(source) {
         };
     }
 }
+function stable(value) {
+    if (Array.isArray(value))
+        return value.map(stable);
+    if (value !== null && typeof value === "object") {
+        const out = {};
+        for (const [key, child] of Object.entries(value).sort(([a], [b]) => a.localeCompare(b))) {
+            out[key] = stable(child);
+        }
+        return out;
+    }
+    return value;
+}
+function stableStringify(value) {
+    return JSON.stringify(stable(value));
+}
+function validatePackPath(path) {
+    if (/^https?:\/\//i.test(path)) {
+        return { error: "unsafe_filename", message: "Aesthetic pack imports only accept local .mosvera.json files, not URLs." };
+    }
+    const file = basename(path);
+    if (file.startsWith(".") || !PACK_EXT.test(file)) {
+        return { error: "unsafe_filename", message: "Aesthetic pack paths must end with .mosvera.json and must not be dotfiles." };
+    }
+    return undefined;
+}
+function readPackSource(args) {
+    if ((args.pack === undefined && args.path === undefined) || (args.pack !== undefined && args.path !== undefined)) {
+        return { error: "invalid_document", message: "Provide exactly one aesthetic pack source: inline pack JSON or a local .mosvera.json path." };
+    }
+    if (args.path !== undefined) {
+        const pathFailure = validatePackPath(args.path);
+        if (pathFailure !== undefined)
+            return pathFailure;
+        const parsed = parseDocument(readFileSync(args.path, "utf8"));
+        if (maybeFail(parsed))
+            return parsed;
+        return { pack: parsed, source: "path", path: args.path };
+    }
+    const parsed = parseDocument(args.pack);
+    if (maybeFail(parsed))
+        return parsed;
+    return { pack: parsed, source: "inline" };
+}
+function readValidPackSource(args, ctx) {
+    const source = readPackSource(args);
+    if (maybeFail(source))
+        return source;
+    const diagnostics = validateAestheticPack(source.pack, { validator: ctx.validator });
+    if (diagnostics.length > 0) {
+        return {
+            error: "schema_failure",
+            message: "Aesthetic pack failed validation.",
+            detail: { valid: false, diagnostics },
+        };
+    }
+    return source;
+}
 function runtimeError(e) {
     if (isResolutionError(e)) {
         const mapped = mapResolutionError(e);
@@ -116,7 +176,7 @@ export function runServerStatus(ctx) {
         fallback_reason: ctx.fallbackReason,
         versions: {
             mcp: SERVER_VERSION,
-            runtime: "0.1.1",
+            runtime: "0.1.2",
         },
         counts,
         diagnostics,
@@ -124,7 +184,10 @@ export function runServerStatus(ctx) {
 }
 export function runListAesthetics(ctx) {
     const aesthetics = listRegistryEntries(ctx.project.registry, "composition");
-    return ok(`Found ${aesthetics.length} aesthetic${aesthetics.length === 1 ? "" : "s"}.`, { aesthetics });
+    const label = aesthetics.length === 1 ? "aesthetic" : "aesthetics";
+    const summary = aesthetics.length === 0 ? "Found 0 aesthetics." :
+        `Found ${aesthetics.length} ${label}:\n${aesthetics.map((entry) => `- ${entry.id}${entry.base !== undefined ? ` (base: ${entry.base})` : ""}`).join("\n")}`;
+    return ok(summary, { aesthetics });
 }
 export function runGetRegistryDocument(ctx, args) {
     if (args.kind === "capability-manifest") {
@@ -154,6 +217,54 @@ export function runValidateRegistry(ctx) {
         diagnostics,
     });
 }
+export function runValidateAestheticPack(ctx, args) {
+    const source = readPackSource(args);
+    if (maybeFail(source))
+        return toolFail(source);
+    const diagnostics = validateAestheticPack(source.pack, { validator: ctx.validator });
+    return ok(diagnostics.length === 0 ? "Aesthetic pack is valid." : "Aesthetic pack is invalid.", {
+        valid: diagnostics.length === 0,
+        source: source.source,
+        path: source.path,
+        diagnostics,
+    });
+}
+export function runPreviewAestheticImport(ctx, args) {
+    const source = readValidPackSource(args, ctx);
+    if (maybeFail(source))
+        return toolFail(source);
+    const options = {
+        validator: ctx.validator,
+        strategies: ctx.project.strategies,
+    };
+    if (args.conflict_strategy !== undefined)
+        options.conflictStrategy = args.conflict_strategy;
+    if (args.strategy_conflict !== undefined)
+        options.strategyConflict = args.strategy_conflict;
+    const plan = previewAestheticPackImport(source.pack, ctx.project.registry, options);
+    if (!plan.valid)
+        return fail("invalid_document", "Aesthetic pack import preview found blocking diagnostics.", { plan });
+    return ok("Previewed aesthetic pack import.", { source: source.source, path: source.path, plan });
+}
+export function runExportAestheticPack(ctx, args) {
+    try {
+        const options = {
+            strategies: ctx.project.strategies,
+        };
+        if (args.id !== undefined)
+            options.id = args.id;
+        if (args.name !== undefined)
+            options.name = args.name;
+        if (args.description !== undefined)
+            options.description = args.description;
+        const pack = exportAestheticPack(args.aesthetic, ctx.project.registry, options);
+        const suggested_filename = `${pack.id}.mosvera.json`;
+        return ok(`Exported aesthetic pack "${pack.id}".`, { pack, suggested_filename });
+    }
+    catch (e) {
+        return toolFail(runtimeError(e));
+    }
+}
 export function runResolveAesthetic(ctx, args) {
     const input = { aesthetic: args.aesthetic };
     if (args.merge_strategies !== undefined)
@@ -325,6 +436,49 @@ export function runWriteMergeStrategies(ctx, args) {
         return toolFail(runtimeError(e));
     }
 }
+export function runImportAestheticPack(ctx, args) {
+    const disabled = writeDisabled(ctx);
+    if (disabled !== undefined)
+        return toolFail(disabled);
+    const source = readValidPackSource(args, ctx);
+    if (maybeFail(source))
+        return toolFail(source);
+    try {
+        const options = {
+            validator: ctx.validator,
+            strategies: ctx.project.strategies,
+        };
+        if (args.conflict_strategy !== undefined)
+            options.conflictStrategy = args.conflict_strategy;
+        if (args.strategy_conflict !== undefined)
+            options.strategyConflict = args.strategy_conflict;
+        const result = importAestheticPack(ctx.project.registry, source.pack, options);
+        if (!result.plan.valid)
+            return fail("invalid_document", "Aesthetic pack import found blocking diagnostics.", { plan: result.plan });
+        for (const kind of registryKinds) {
+            const collection = kind === "template" ? result.pack.documents.templates :
+                kind === "modifier" ? result.pack.documents.modifiers :
+                    kind === "palette" ? result.pack.documents.palettes :
+                        result.pack.documents.compositions;
+            for (const document of Object.values(collection ?? {})) {
+                saveProjectDocument(ctx.registryDir, kind, document);
+            }
+        }
+        if (stableStringify(result.strategies) !== stableStringify(ctx.project.strategies)) {
+            writeMergeStrategies(ctx.registryDir, result.strategies);
+        }
+        reloadContext(ctx);
+        return ok(`Imported aesthetic pack "${result.pack.id}".`, {
+            source: source.source,
+            path: source.path,
+            plan: result.plan,
+            entrypoint: result.plan.installed_entrypoint,
+        });
+    }
+    catch (e) {
+        return toolFail(runtimeError(e));
+    }
+}
 export function errorCodeFromResult(result) {
     const code = result.structuredContent?.error;
     return typeof code === "string" ? code : undefined;

package/dist/types.d.ts

@@ -27,7 +27,7 @@ export interface ToolContext {
     adapters?: Record<string, ProviderAdapter>;
 }
 /** Closed MCP-layer error taxonomy (D2/D7 in the design spec). */
-export type ToolErrorCode = "invalid_document" | "unknown_reference" | "unknown_provider" | "unsafe_filename" | "schema_failure" | "write_disabled" | "registry_unwritable" | "inheritance_cycle" | "reference_cycle" | "multiple_inheritance_unsupported";
+export type ToolErrorCode = "invalid_document" | "unknown_reference" | "unknown_provider" | "unsafe_filename" | "schema_failure" | "strategy_conflict" | "write_disabled" | "registry_unwritable" | "inheritance_cycle" | "reference_cycle" | "multiple_inheritance_unsupported";
 export interface ToolError {
     error: ToolErrorCode;
     detail?: JsonObject | string;

package/mcpb/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": "0.3",
   "name": "mosvera-mcp",
   "display_name": "Mosvera",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Resolve, compile, and save local Mosvera aesthetics from Claude Desktop.",
   "long_description": "Mosvera runs locally against your own aesthetic registry. It lets Claude list named aesthetics, resolve them to canonical Mosvera models, compile portable design tokens and CSS variables, and save registry documents without sending provider requests or storing secrets.",
   "author": {
@@ -36,6 +36,9 @@
     { "name": "get_registry_document", "description": "Fetch a template, modifier, palette, composition, or capability manifest." },
     { "name": "validate_document", "description": "Validate one Mosvera document against a schema kind." },
     { "name": "validate_registry", "description": "Validate the active local registry." },
+    { "name": "validate_aesthetic_pack", "description": "Validate an inline or local .mosvera.json aesthetic pack." },
+    { "name": "preview_aesthetic_import", "description": "Preview importing an aesthetic pack without writing files." },
+    { "name": "export_aesthetic_pack", "description": "Export a named aesthetic as a portable .mosvera.json pack." },
     { "name": "resolve_aesthetic", "description": "Resolve a named or inline aesthetic to the canonical Mosvera model." },
     { "name": "compile_design_tokens", "description": "Compile an aesthetic into portable design tokens and CSS variables." },
     { "name": "compile_provider_payload", "description": "Compile a deterministic provider payload without making provider HTTP calls." },
@@ -43,7 +46,8 @@
     { "name": "save_aesthetic", "description": "Create or update a named aesthetic in the active local registry." },
     { "name": "save_registry_document", "description": "Create or update an advanced registry document." },
     { "name": "delete_registry_document", "description": "Delete a registry document from the active local registry." },
-    { "name": "write_merge_strategies", "description": "Replace merge-strategies.json with deterministic JSON." }
+    { "name": "write_merge_strategies", "description": "Replace merge-strategies.json with deterministic JSON." },
+    { "name": "import_aesthetic_pack", "description": "Import an aesthetic pack into the active local registry." }
   ],
   "keywords": ["mosvera", "aesthetic-infrastructure", "mcp", "design-tokens"],
   "license": "Apache-2.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosvera/mcp",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Run Mosvera as local MCP tools for agents, editors, and Claude Desktop.",
   "license": "Apache-2.0",
   "type": "module",
@@ -41,8 +41,8 @@
     "ci": "npm run build && npm run typecheck && npm test",
     "clean": "rm -rf dist",
     "mcpb:stage": "npm run build && node scripts/stage-mcpb.mjs",
-    "mcpb:pack": "npm run mcpb:stage && mcpb pack build/mcpb/mosvera build/mosvera/mosvera-mcp-0.1.2.mcpb",
-    "mcpb:inspect": "node scripts/inspect-mcpb.mjs build/mosvera/mosvera-mcp-0.1.2.mcpb",
+    "mcpb:pack": "npm run mcpb:stage && mcpb pack build/mcpb/mosvera build/mosvera/mosvera-mcp-0.1.4.mcpb",
+    "mcpb:inspect": "node scripts/inspect-mcpb.mjs build/mosvera/mosvera-mcp-0.1.4.mcpb",
     "prepublishOnly": "npm run build && npm run typecheck && npm test",
     "start": "tsx src/server.ts",
     "test": "vitest run",
@@ -56,7 +56,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@mosvera/runtime": "^0.1.1",
+    "@mosvera/runtime": "^0.1.2",
     "@mosvera/provider-base": "^0.1.1",
     "@mosvera/provider-flux": "^0.1.1",
     "@mosvera/provider-openai": "^0.1.1",