developer-tools Static interface comparison
MetaEngine MCP
1.4.2 1.5.0
1 new unknown capability requires explicit review.
View the upgrade review as Markdown
A shareable summary of this comparison for an issue, pull request or ticket. Select the text and copy it.
INTERFACE DIFF
What changed, tool by tool
- 1Added tools
- 0Removed tools
- 2Modified tools
- 1Input-schema changes
- 0Output-schema changes
- 1Declared authority changes
3 tools with recorded changes
generate_codeModifiedWhat changed
- generate_code — Schema change: input property added: skipEnumMembersValidation.
- generate_code: description changed.
Why it could matter
- Calls or consumers built for the earlier schema may need to change.
- Models choose and call tools partly from their descriptions.
What to verify
- Validate representative existing tool calls against the new argument schema.
- Spot-check that agents still select this tool as intended.
- Declared effect
- unknown → unknown
- Description
- PreviousSemantic code generation for TypeScript, Python, Go, C#, Java, Kotlin, Groovy, Scala, Swift, PHP, and Rust. Generates compilable source files with perfect imports and cross-references from structured JSON specs. # MetaEngine MCP — AI Code Generation Guide MetaEngine is a semantic code generation system exposed via MCP. You describe types, relationships, and methods as structured JSON — MetaEngine produces compilable, correctly-imported source files for TypeScript, C#, Python, Go, Java, Kotlin, Groovy, Scala, Swift, and PHP. Unlike templates, it resolves cross-references, manages imports, and handles language idioms automatically. This matters for AI usage because a single well-formed JSON call replaces dozens of error-prone file writes. --- ## Critical Rules These are the rules that cause the most failures when violated. Read them first. ### 1. Generate ALL related types in ONE call `typeIdentifier` references only resolve within the current batch. If `UserService` references `User`, both must be in the same `generate_code` call. ```jsonc // ONE call with both types { "classes": [ {"name": "User", "typeIdentifier": "user", ...}, {"name": "UserService", ...references "user"...} ] } ``` ### 2. Properties = type declarations. CustomCode = everything else. `properties[]` declares fields with types only. `customCode[]` handles methods, initialized fields, and any code with logic. One `customCode` item = exactly one member. ```jsonc // Property: type only, no initialization "properties": [{"name": "id", "primitiveType": "String"}] // CustomCode: method or initialized field "customCode": [ {"code": "private http = inject(HttpClient);"}, {"code": "getAll(): T[] { return this.items; }"} ] ``` **Never put methods in properties.** Never put uninitialized type declarations in customCode. ### 3. Use templateRefs for internal types in customCode When customCode references a type from the same batch, use `$placeholder` syntax with `templateRefs`. This triggers automatic import resolution. Without templateRefs, MetaEngine cannot generate the import/using directive. ```jsonc "customCode": [{ "code": "getUser(): Promise<$user> { ... }", "templateRefs": [{"placeholder": "$user", "typeIdentifier": "user"}] }] ``` **Critical in C#**: Every internal type reference in customCode MUST use templateRefs, or `using` directives for cross-namespace types won't be generated. Raw strings like `IUserRepository` without templateRefs will compile-fail across namespaces. ### 4. Never add framework imports to customImports MetaEngine auto-imports standard library types. Adding them manually causes duplication or errors. | Language | Auto-imported (never specify) | |------------|--------------------------------------------------------------------------------------------------| | C# | System.*, Collections.Generic, Linq, Tasks, Text, IO, Net.Http, DataAnnotations, Extensions.* | | Python | typing.*, pydantic (BaseModel, Field), datetime, decimal, enum, abc, dataclasses | | Java | java.util.*, java.time.*, java.util.stream.*, java.math.*, jakarta.validation.*, jackson.* | | Kotlin | java.time.*, java.math.*, java.util.UUID, kotlinx.serialization.* | | Go | time, fmt, log, strings, strconv, errors, context, sync, io, os, encoding/json, net/http, +more | | Swift | Foundation (Date, UUID, URL, Decimal, URLSession, JSONEncoder, JSONDecoder, etc.) | | Rust | std::collections (HashMap, HashSet), chrono, uuid, rust_decimal, serde | | Groovy | java.time.*, java.math.*, java.util (UUID, Date), java.io (File, InputStream, OutputStream) | | Scala | java.time.*, scala.math (BigDecimal, BigInt), java.util.UUID, scala.collection.mutable.* | | PHP | DateTime*, DateTimeImmutable, Exception*, ArrayObject, JsonSerializable, Stringable | | TypeScript | (no imports needed — built-in types) | Only use `customImports` for external libraries (`@angular/core`, `FluentValidation`, `rxjs`, etc.). ### 5. templateRefs are ONLY for internal types External library types must use `customImports`. If it's in the same MCP call → use `typeIdentifier` or `templateRefs`. If it's an external library → use `customImports`. Never mix these. ### 6. Constructor parameters auto-create properties In C#, Java, Go, and Groovy, constructor parameters automatically become class properties. Do NOT duplicate them in `properties[]` — this causes "Sequence contains more than one matching element" errors. ```jsonc // WRONG for C#/Java/Go/Groovy "constructorParameters": [{"name": "email", "type": "string"}], "properties": [{"name": "email", "type": "string"}] // DUPLICATE! // CORRECT — only in constructorParameters "constructorParameters": [{"name": "email", "type": "string"}] // additional non-constructor properties go in properties[] ``` ### 7. Virtual types don't generate files `arrayTypes`, `dictionaryTypes`, `concreteGenericClasses`, and `concreteGenericInterfaces` create reusable type references only. They never produce files. They're used by referencing their `typeIdentifier` in properties of file-generating types. ### 8. Opt in to runtime `.js` imports for Node16/NodeNext TypeScript Node16 and NodeNext ESM execute the emitted JavaScript, so relative imports in the TypeScript source must name the runtime `.js` file. Set the option on `generate_code` or in a `load_spec_from_file` document: ```json { "language": "typescript", "typeScriptOptions": { "relativeImportExtension": "js" } } ``` MetaEngine then emits specifiers such as `./worker.js` and uses `import type` when the imported declaration is intrinsically type-only. Omit `typeScriptOptions` (or select `"none"`) to preserve extensionless relative imports for bundler-oriented projects. --- ## Pattern Reference ### Basic interfaces with cross-references ```jsonc { "language": "typescript", "interfaces": [ {"name": "Address", "typeIdentifier": "address", "properties": [ {"name": "street", "primitiveType": "String"}, {"name": "city", "primitiveType": "String"} ]}, {"name": "User", "typeIdentifier": "user", "properties": [ {"name": "id", "primitiveType": "String"}, {"name": "address", "typeIdentifier": "address"} ]} ] } ``` Produces two files with automatic imports between them. ### Class with inheritance and methods ```jsonc { "classes": [ {"name": "BaseEntity", "typeIdentifier": "base-entity", "isAbstract": true, "properties": [{"name": "id", "primitiveType": "String"}]}, {"name": "User", "typeIdentifier": "user", "baseClassTypeIdentifier": "base-entity", "properties": [{"name": "email", "primitiveType": "String"}], "customCode": [ {"code": "getDisplayName(): string { return this.email; }"} ]} ] } ``` ### Generic class + concrete implementation ```jsonc { "classes": [ {"name": "Repository", "typeIdentifier": "repo-generic", "genericArguments": [{ "name": "T", "constraintTypeIdentifier": "base-entity", "propertyName": "items", "isArrayProperty": true }], "customCode": [ {"code": "add(item: T): void { this.items.push(item); }"}, {"code": "getAll(): T[] { return this.items; }"} ]}, {"name": "User", "typeIdentifier": "user", "baseClassTypeIdentifier": "base-entity", "properties": [{"name": "email", "primitiveType": "String"}]}, {"name": "UserRepository", "typeIdentifier": "user-repo-class", "baseClassTypeIdentifier": "user-repo-concrete", "customCode": [{ "code": "findByEmail(email: string): $user | undefined { return this.getAll().find(u => u.email === email); }", "templateRefs": [{"placeholder": "$user", "typeIdentifier": "user"}] }]} ], "concreteGenericClasses": [{ "identifier": "user-repo-concrete", "genericClassIdentifier": "repo-generic", "genericArguments": [{"typeIdentifier": "user"}] }] } ``` The `concreteGenericClasses` entry creates a virtual `Repository<User>` type. The class extends it via `baseClassTypeIdentifier`. MetaEngine generates `extends Repository<User>` with correct imports. ### Array and dictionary types ```jsonc { "arrayTypes": [ {"typeIdentifier": "user-list", "elementTypeIdentifier": "user"}, {"typeIdentifier": "string-array", "elementPrimitiveType": "String"} ], "dictionaryTypes": [ {"typeIdentifier": "scores", "keyPrimitiveType": "String", "valuePrimitiveType": "Number"}, {"typeIdentifier": "user-lookup", "keyPrimitiveType": "String", "valueTypeIdentifier": "user"} ] } ``` Then reference via `"typeIdentifier": "user-list"` in properties. **C# note**: arrayTypes generate `IEnumerable<T>`. If you need `List<T>`, use `"type": "List<$user>"` with templateRefs instead. ### Complex type expressions with templateRefs ```jsonc "properties": [{ "name": "cache", "type": "Map<string, $resp>", "templateRefs": [{"placeholder": "$resp", "typeIdentifier": "api-response"}] }] ``` templateRefs work in properties, customCode, and decorators. The `$placeholder` gets replaced with the resolved type name and triggers import generation. ### Enum + class that uses it ```jsonc { "enums": [{"name": "OrderStatus", "typeIdentifier": "order-status", "members": [{"name": "Pending", "value": 0}, {"name": "Shipped", "value": 2}]}], "classes": [{"name": "Order", "typeIdentifier": "order", "properties": [{"name": "status", "typeIdentifier": "order-status"}], "customCode": [{ "code": "updateStatus(s: $status): void { this.status = s; }", "templateRefs": [{"placeholder": "$status", "typeIdentifier": "order-status"}] }]}] } ``` Enums auto-suffix filenames: `order-status.enum.ts` (TS), `OrderStatus.cs` (C#). ### Service with external dependency injection ```jsonc { "classes": [{ "name": "ApiService", "typeIdentifier": "api-service", "decorators": [{"code": "@Injectable({ providedIn: 'root' })"}], "customImports": [ {"path": "@angular/core", "types": ["Injectable", "inject"]}, {"path": "@angular/common/http", "types": ["HttpClient"]} ], "customCode": [ {"code": "private http = inject(HttpClient);"}, {"code": "getUsers(): Observable<$list> { return this.http.get<$list>('/api/users'); }", "templateRefs": [{"placeholder": "$list", "typeIdentifier": "user-array"}]} ] }], "arrayTypes": [{"typeIdentifier": "user-array", "elementTypeIdentifier": "user-dto"}] } ``` ### CustomFiles for type aliases and barrel exports ```jsonc { "customFiles": [{ "name": "types", "path": "shared", "identifier": "shared-types", "customCode": [ {"code": "export type UserId = string;"}, {"code": "export type Email = string;"} ] }], "classes": [{ "name": "UserHelper", "path": "helpers", "customImports": [{"path": "shared-types"}], "customCode": [{"code": "static format(email: Email): string { return email.trim(); }"}] }] } ``` The `identifier` on the customFile enables import resolution. `customImports` referencing the identifier auto-resolves to the relative path. ### Interface with method signatures (TypeScript/C#) For interfaces that will be `implements`/`:` by a class, define method signatures in `customCode`, NOT as function-typed properties: ```jsonc { "interfaces": [{ "name": "IUserRepository", "typeIdentifier": "user-repo", "fileName": "i-user-repository", "customCode": [ {"code": "findAll(): Promise<$user[]>;", "templateRefs": [{"placeholder": "$user", "typeIdentifier": "user"}]}, {"code": "findById(id: string): Promise<$user | null>;", "templateRefs": [{"placeholder": "$user", "typeIdentifier": "user"}]} ] }] } ``` If you use function-typed properties instead (e.g. `"type": "() => Promise<User[]>"`), the implementing class will duplicate them as property declarations alongside your customCode methods. --- ## Language-Specific Notes ### TypeScript - MetaEngine strips `I` prefix from interface names. `IUserRepository` → exported as `UserRepository`. Use `fileName` to control the file name if collisions arise. - `Number` → `number`, `String` → `string`, `Boolean` → `boolean`, `Date` → `Date`, `Any` → `unknown` - Auto-indent for customCode newlines (`\n`) - Decorators supported directly ### C# - `I` prefix preserved on interface names - `Number` → `int` (not `double`). Use `"type": "decimal"` or `"type": "double"` for non-integer numbers. - `packageName` sets the namespace. Omit for GlobalUsings pattern. - Interface properties generate `{ get; }`. Class properties generate `{ get; set; }`. - arrayTypes generate `IEnumerable<T>`. For `List<T>`, use `type` with templateRefs: `"type": "List<$user>"` - `isOptional` on properties generates `string?` (nullable reference type) ### Python - Must provide explicit indentation (4 spaces) after `\n` in customCode - typing imports are automatic ### Go - Requires `packageName` for multi-file projects - No constructors — use factory functions in customCode --- ## Common Mistakes 1. **Don't** reference a `typeIdentifier` that doesn't exist in the batch → the property is silently dropped. **Do** verify every typeIdentifier matches a defined type in the same call. 2. **Don't** put method signatures as function-typed properties on interfaces you'll `implements`. **Do** use `customCode` for interface method signatures when a class will implement them. 3. **Don't** write internal type names as raw strings in customCode (e.g., `"code": "private repo: IUserRepository"`). **Do** use templateRefs: `"code": "private repo: $repo"` with `"templateRefs": [{"placeholder": "$repo", "typeIdentifier": "user-repo"}]`. 4. **Don't** use `arrayTypes` in C# when you need `List<T>`. **Do** use `"type": "List<$user>"` with templateRefs for mutable list types. 5. **Don't** add `System.*`, `typing.*`, `java.util.*` etc. to customImports. **Do** let MetaEngine handle all framework imports automatically. 6. **Don't** duplicate constructor parameter names in the `properties` array (C#/Java/Go/Groovy). **Do** put shared fields only in `constructorParameters` and additional-only fields in `properties`. 7. **Don't** use reserved words (`delete`, `class`, `import`) as property names. **Do** use safe alternatives (`remove`, `clazz`, `importData`). 8. **Don't** generate related types in separate MCP calls. **Do** batch everything in one call — cross-file imports only resolve within a single batch. 9. **Don't** expect `Number` to map to `double` in C# — it maps to `int`. **Do** use `"type": "double"` or `"type": "decimal"` explicitly when needed. 10. **Don't** forget `fileName` when both an `I`-prefixed interface and its implementing class would collide in TypeScript. **Do** set `"fileName": "i-user-repository"` on the interface to prevent file name conflicts.
- CurrentGenerate source files from a structured type graph for TypeScript, Python, Go, C#, Java, Kotlin, Groovy, Scala, Swift, PHP, and Rust. Use explicit templateRefs to link target-language customCode to generated types and imports. For compact field maps and repeated patterns, use generate_from_recipe. # MetaEngine MCP — generation guide MetaEngine generates source files from structured type definitions and target-language code. Type and model generation supports TypeScript, Python, Go, C#, Java, Kotlin, Groovy, Scala, Swift, PHP, and Rust. ## Choose a tool - `generate_from_recipe`: compact property maps, explicit references, reusable parameter templates, and local JSON data rows. Start with [RECIPES.md](./RECIPES.md), also available as `metaengine://guide/recipes`. - `generate_code`: the existing complete native JSON payload. - `load_spec_from_file`: the same native payload read from a local file. - `generate_openapi`, `generate_graphql`, `generate_protobuf`, `generate_sql`: convert an existing schema using their tool-specific options. The three type-graph tools share the hosted generation API and local file writer. `dryRun` previews source without writing it; `skipExisting` defaults to true. The hosted request limit is 250 counted types, with the existing counting rule documented in the recipe guide. ## References and batch boundaries Generate related types together. IDs resolve within a single request. A class or interface declares `typeIdentifier`; a property refers to it with the same field. Recipes also accept the compact aliases `id` on definitions and `ref` on map properties. Use `templateRefs` wherever target-language text refers to an internal type: ```json { "code": "read(): Promise<$item>;", "templateRefs": [{ "placeholder": "$item", "typeIdentifier": "item" }] } ``` The reference resolves the type name and supports import generation. Merely writing an internal type's name in a raw code string does not create a graph reference. `templateRefs` are supported on custom code, native property type expressions, constructor parameter type expressions, and decorators; properties also support `commentTemplateRefs`. External types use `customImports` with the target language's import path and names. The generator handles recognized standard-library imports. It does not install external packages. Custom-file identifiers belong to import resolution, not the regular type graph. Where supported, refer to one with `customImports.path`; for C#, use the custom file's namespace. Do not target a custom-file identifier with `ref` or `templateRefs.typeIdentifier`. Code inside a custom file can still use `templateRefs` to refer to ordinary generated types. ## Declarations and custom code Use `properties` for typed declarations. Use `customCode` for methods, initialized fields, constructors with bodies, and other target-language members. Keep each member in its own code block. `customFiles` produce files without a class wrapper and can hold functions, aliases, or other source content. Use interface method signatures in `customCode` when classes will implement those methods. A function-typed property and a method are different declarations. Constructor parameters can create properties in the selected language. Do not repeat a constructor parameter as an additional property. For a constructor with custom logic, supply the constructor code and any fields explicitly in `customCode`. The generator renders your supplied structure and code. Compile the result in its real project to check method bodies, dependencies, language rules, and compiler options. ## Native features retained by recipes | Feature | Native fields | | --- | --- | | Named types | `classes`, `interfaces`, `enums`, `typeIdentifier`, `name`, `path`, `fileName` | | Properties | `name`, `primitiveType`, `typeIdentifier`, `type`, `isOptional`, `isInitializer`, comments and decorators | | Inheritance | `baseClassTypeIdentifier`, `interfaceTypeIdentifiers` | | Generic definitions | `genericArguments` with name, constraint, and optional property metadata | | Concrete generic references | `concreteGenericClasses`, `concreteGenericInterfaces`, `identifier`, `genericClassIdentifier`, `genericArguments` | | Collection references | `arrayTypes`, `dictionaryTypes` | | Target-language content | `customCode`, `customFiles`, `customImports`, `templateRefs` | | Generation settings | `initialize`, `packageName`, `typeScriptOptions`, `skipEnumMembersValidation` | Array, dictionary, and concrete generic definitions are virtual types: they can be referenced but do not generate files of their own. A concrete generic's `genericClassIdentifier` refers to its generic declaration, including for interfaces; keep that existing field name. ## Language notes ### TypeScript For Node16/NodeNext ESM, use `typeScriptOptions: {"relativeImportExtension":"js"}` so generated `.ts` source imports runtime `.js` paths. The default uses extensionless relative imports. Native primitives `String`, `Number`, `Boolean`, `Date`, and `Any` render as `string`, `number`, `boolean`, `Date`, and `unknown`. Recipes spell those primitive choices in lowercase. For native expressions such as `Map<string, $item>`, use `type` plus `templateRefs`. The engine can normalize interface names. Use references to obtain the rendered name, and explicit `fileName` values when an interface and class would otherwise share a file name. ### C# `packageName` sets the root namespace; type paths contribute namespace segments. Omit the package name when you want no root namespace. Do not put namespace wrappers in individual custom members. `Number` selects `int`. Use native `type: "decimal"` or `type: "double"` for those numeric types. Optional properties use the language's nullable representation. Configure nullable reference types and the language version in the consuming project. Use `templateRefs` for internal cross-namespace types in custom code. For a specific collection such as `List<T>`, use `type: "List<$item>"` with a reference. The language emitter chooses the collection spelling for a virtual `arrayTypes` definition. ### Other languages Keep method bodies and native type expressions in the selected language. Python bodies need valid indentation. Go multi-file output needs a package/module layout appropriate to the consuming project. Add the generated code's required libraries to the target project. ## Before generation 1. Include every internally referenced type in the same batch. 2. Use structured properties for declarations and custom code for behavior. 3. Make every internal reference in a raw type expression or code block explicit with `templateRefs`. 4. Choose output paths, native imports, package/namespace names, and compiler options deliberately. 5. Review and compile the generated output. [Complete examples](./EXAMPLES.md) · [Recipe syntax and limits](./RECIPES.md)
Input schema
Property Previous (1.4.2) Current (1.5.0) Change skipEnumMembersValidationnot present booleanoptional - Added
150 unchanged entries
(schema root)arrayTypesarrayTypes › [items]arrayTypes › [items] › elementPrimitiveTypearrayTypes › [items] › elementTypeIdentifierarrayTypes › [items] › typeIdentifierclassesclasses › [items]classes › [items] › baseClassTypeIdentifierclasses › [items] › commentclasses › [items] › constructorParametersclasses › [items] › constructorParameters › [items]classes › [items] › constructorParameters › [items] › nameclasses › [items] › constructorParameters › [items] › primitiveTypeclasses › [items] › constructorParameters › [items] › templateRefsclasses › [items] › constructorParameters › [items] › templateRefs › [items]classes › [items] › constructorParameters › [items] › templateRefs › [items] › placeholderclasses › [items] › constructorParameters › [items] › templateRefs › [items] › typeIdentifierclasses › [items] › constructorParameters › [items] › typeclasses › [items] › constructorParameters › [items] › typeIdentifierclasses › [items] › customCodeclasses › [items] › customCode › [items]classes › [items] › customCode › [items] › codeclasses › [items] › customCode › [items] › templateRefsclasses › [items] › customCode › [items] › templateRefs › [items]classes › [items] › customCode › [items] › templateRefs › [items] › placeholderclasses › [items] › customCode › [items] › templateRefs › [items] › typeIdentifierclasses › [items] › customImportsclasses › [items] › customImports › [items]classes › [items] › customImports › [items] › pathclasses › [items] › customImports › [items] › typesclasses › [items] › customImports › [items] › types › [items]classes › [items] › decoratorsclasses › [items] › decorators › [items]classes › [items] › decorators › [items] › codeclasses › [items] › decorators › [items] › templateRefsclasses › [items] › decorators › [items] › templateRefs › [items]classes › [items] › fileNameclasses › [items] › genericArgumentsclasses › [items] › genericArguments › [items]classes › [items] › genericArguments › [items] › constraintTypeIdentifierclasses › [items] › genericArguments › [items] › isArrayPropertyclasses › [items] › genericArguments › [items] › nameclasses › [items] › genericArguments › [items] › propertyNameclasses › [items] › interfaceTypeIdentifiersclasses › [items] › interfaceTypeIdentifiers › [items]classes › [items] › isAbstractclasses › [items] › nameclasses › [items] › pathclasses › [items] › propertiesclasses › [items] › properties › [items]classes › [items] › properties › [items] › commentclasses › [items] › properties › [items] › commentTemplateRefsclasses › [items] › properties › [items] › commentTemplateRefs › [items]classes › [items] › properties › [items] › decoratorsclasses › [items] › properties › [items] › decorators › [items]classes › [items] › properties › [items] › decorators › [items] › codeclasses › [items] › properties › [items] › decorators › [items] › templateRefsclasses › [items] › properties › [items] › decorators › [items] › templateRefs › [items]classes › [items] › properties › [items] › isInitializerclasses › [items] › properties › [items] › isOptionalclasses › [items] › properties › [items] › nameclasses › [items] › properties › [items] › primitiveTypeclasses › [items] › properties › [items] › templateRefsclasses › [items] › properties › [items] › templateRefs › [items]classes › [items] › properties › [items] › templateRefs › [items] › placeholderclasses › [items] › properties › [items] › templateRefs › [items] › typeIdentifierclasses › [items] › properties › [items] › typeclasses › [items] › properties › [items] › typeIdentifierclasses › [items] › typeIdentifierconcreteGenericClassesconcreteGenericClasses › [items]concreteGenericClasses › [items] › genericArgumentsconcreteGenericClasses › [items] › genericArguments › [items]concreteGenericClasses › [items] › genericArguments › [items] › primitiveTypeconcreteGenericClasses › [items] › genericArguments › [items] › typeIdentifierconcreteGenericClasses › [items] › genericClassIdentifierconcreteGenericClasses › [items] › identifierconcreteGenericInterfacesconcreteGenericInterfaces › [items]concreteGenericInterfaces › [items] › genericArgumentsconcreteGenericInterfaces › [items] › genericArguments › [items]concreteGenericInterfaces › [items] › genericArguments › [items] › primitiveTypeconcreteGenericInterfaces › [items] › genericArguments › [items] › typeIdentifierconcreteGenericInterfaces › [items] › genericClassIdentifierconcreteGenericInterfaces › [items] › identifiercustomFilescustomFiles › [items]customFiles › [items] › customCodecustomFiles › [items] › customCode › [items]customFiles › [items] › customCode › [items] › codecustomFiles › [items] › customCode › [items] › templateRefscustomFiles › [items] › customCode › [items] › templateRefs › [items]customFiles › [items] › customCode › [items] › templateRefs › [items] › placeholdercustomFiles › [items] › customCode › [items] › templateRefs › [items] › typeIdentifiercustomFiles › [items] › customImportscustomFiles › [items] › customImports › [items]customFiles › [items] › customImports › [items] › pathcustomFiles › [items] › customImports › [items] › typescustomFiles › [items] › customImports › [items] › types › [items]customFiles › [items] › fileNamecustomFiles › [items] › identifiercustomFiles › [items] › namecustomFiles › [items] › pathdictionaryTypesdictionaryTypes › [items]dictionaryTypes › [items] › keyPrimitiveTypedictionaryTypes › [items] › keyTypeIdentifierdictionaryTypes › [items] › typeIdentifierdictionaryTypes › [items] › valuePrimitiveTypedictionaryTypes › [items] › valueTypeIdentifierdryRunenumsenums › [items]enums › [items] › commentenums › [items] › fileNameenums › [items] › membersenums › [items] › members › [items]enums › [items] › members › [items] › nameenums › [items] › members › [items] › stringValueenums › [items] › members › [items] › valueenums › [items] › nameenums › [items] › pathenums › [items] › typeIdentifierinitializeinterfacesinterfaces › [items]interfaces › [items] › commentinterfaces › [items] › customCodeinterfaces › [items] › customCode › [items]interfaces › [items] › customImportsinterfaces › [items] › customImports › [items]interfaces › [items] › decoratorsinterfaces › [items] › decorators › [items]interfaces › [items] › fileNameinterfaces › [items] › genericArgumentsinterfaces › [items] › genericArguments › [items]interfaces › [items] › interfaceTypeIdentifiersinterfaces › [items] › interfaceTypeIdentifiers › [items]interfaces › [items] › nameinterfaces › [items] › pathinterfaces › [items] › propertiesinterfaces › [items] › properties › [items]interfaces › [items] › typeIdentifierlanguageoutputPathpackageNameskipExistingtypeScriptOptionstypeScriptOptions › relativeImportExtension
No output schema is recorded for this tool in either release.
Link to this toolExact JSON from the published snapshots
Loads the exact recorded definitions of this tool from both releases. The full snapshots are linked under Evidence and provenance.
generate_from_recipeAddedWhat changed
- New tool generate_from_recipe, declared with unknown effect.
Why it could matter
- Valyd could not determine this tool’s effect from its declared interface, so its authority is not known.
What to verify
- Read the tool’s documentation and schema before allowing agents to use it.
- Declared effect
- — → unknown
Input schema
Property Previous (1.4.2) Current (1.5.0) Change (schema root)not present object, additionalProperties=false, oneOf (2) - Added
dryRunnot present booleanoptional - Added
outputPathnot present stringoptional - Added
recipenot present object, additionalProperties=falseoptional - Added
recipe › arrayTypesnot present array | nulloptional - Added
recipe › arrayTypes › [items]not present object - Added
recipe › classesnot present array | nulloptional - Added
recipe › classes › [items]not present object - Added
recipe › concreteGenericClassesnot present array | nulloptional - Added
recipe › concreteGenericClasses › [items]not present object - Added
recipe › concreteGenericInterfacesnot present array | nulloptional - Added
recipe › concreteGenericInterfaces › [items]not present object - Added
recipe › customFilesnot present array | nulloptional - Added
recipe › customFiles › [items]not present object - Added
recipe › dictionaryTypesnot present array | nulloptional - Added
recipe › dictionaryTypes › [items]not present object - Added
recipe › dryRunnot present booleanoptional - Added
recipe › enumsnot present array | nulloptional - Added
recipe › enums › [items]not present object - Added
recipe › initializenot present boolean | nulloptional - Added
recipe › inputsnot present objectoptional - Added
recipe › instancesnot present arrayoptional - Added
recipe › instances › [items]not present object - Added
recipe › interfacesnot present array | nulloptional - Added
recipe › interfaces › [items]not present object - Added
recipe › languagenot present string, enum (11)required - Added
recipe › outputPathnot present stringoptional - Added
recipe › packageNamenot present string | nulloptional - Added
recipe › recipeVersionnot present integer, const=1required - Added
recipe › skipEnumMembersValidationnot present boolean | nulloptional - Added
recipe › skipExistingnot present booleanoptional - Added
recipe › templatesnot present objectoptional - Added
recipe › typeScriptOptionsnot present object | null, additionalProperties=falseoptional - Added
recipe › typeScriptOptions › relativeImportExtensionnot present string, enum (2)optional - Added
recipeFilePathnot present stringoptional - Added
skipExistingnot present booleanoptional - Added
No output schema is recorded for this tool in either release.
Link to this toolExact JSON from the published snapshots
Loads the exact recorded definitions of this tool from both releases. The full snapshots are linked under Evidence and provenance.
load_spec_from_fileModifiedWhat changed
- load_spec_from_file: description changed.
Why it could matter
- Models choose and call tools partly from their descriptions.
What to verify
- Spot-check that agents still select this tool as intended.
- Declared effect
- unknown → unknown
- Description
- PreviousLoad code generation spec from a JSON file - Perfect for complex architectures and reusable templates! Instead of constructing large JSON specs in memory, load them from version-controlled .json files. All the same functionality as generate_code (outputPath, skipExisting, dryRun) but with zero memory overhead. Benefits: - Drastically reduced AI context usage (just pass file path!) - Version control your architecture patterns - Reusable templates across projects - Supports complex multi-file generations without context bloat Usage: 1. Create a .json file with your spec (same structure as generate_code) 2. Call this tool with the file path 3. Optionally override outputPath, skipExisting, or dryRun Example spec file (user-system.json): { "language": "typescript", "classes": [{"name": "User", ...}], "interfaces": [{...}] } Then call: load_spec_from_file({specFilePath: "specs/user-system.json", outputPath: "src"})
- CurrentRead an existing generate_code JSON payload from a local file and run the same generation flow. Use generate_from_recipe for compact field maps and reusable JSON templates. outputPath, skipExisting, and dryRun arguments override values in the file.
Input schema
Input schema unchanged.
5 unchanged entries
(schema root)dryRunoutputPathskipExistingspecFilePath
No output schema is recorded for this tool in either release.
Link to this toolExact JSON from the published snapshots
Loads the exact recorded definitions of this tool from both releases. The full snapshots are linked under Evidence and provenance.
No tools match these filters.
5 tools with no recorded change
generate_graphqlgenerate_openapigenerate_protobufgenerate_sqlmetaengine_initialize
Evidence and provenance
- Static findings
- FAIL from Modelara’s automated analysis of the two declared interfaces. A policy outcome, not a security rating or a runtime test.
- Human review
- Pending human review. No reviewer decision is recorded for this comparison.
- Published evidence
- Part of Valyd’s published data generation listed in valyd-data-source.json. Published records are not rewritten.
Show provenance and exact files
- Comparison
metaengine/1.4.2~1.5.0The published comparison identifier.- Analyzer
modelara v0.1.8Policy version not recorded.Analyzed Nov 3, 2026, 4:14 AM UTC.- Distribution
npm- Previous release
@metaengine/mcp-server@1.4.27 tools · published by the registry Aug 13, 2026, 2:05 PM UTCArtifact integritysha512-st9jVJeDLO6IM57PAKMMPQl2A7x1zI2T4ZDHz+wuaUPpaMlSFJMYZysTQiuTwpAZsfC9OTGnfXvj/CU9UvIqZg==Interface fingerprintsha256:d76c8e59b4d16487af153372eb4cb2dbe24761fa3cae01875a8582f7cf576422Exact interface snapshot (JSON)- Current release
@metaengine/mcp-server@1.5.08 tools · published by the registry Sep 15, 2026, 6:24 PM UTCArtifact integritysha512-yntTRl2igzYFBe9gWKrBcjwbnL4El1OTMac0wlK2EuJnMiv+elpNm5i2pyuL9yO0WJHUa+e8vE+KqXKGrTbNRQ==Interface fingerprintsha256:5cc01d82846a9b82a9d10f6e7c14c0a14d81982b72bbe75c5d4e36ddd2877475Exact interface snapshot (JSON)- Comparison record
- Exact comparison record (JSON)
The integrity value or digest identifies the exact artifact that was inspected; it does not show that the package is safe. The interface fingerprint identifies the declared tools and schemas Modelara recorded for that release.
MODELARA ANALYSIS OUTPUT
Interface findings
Policy failures
1 findinggenerate_from_recipeFAILAdded
Requires review
1 findinggenerate_codeREVIEWChangedShow details
input property added: skipEnumMembersValidation
Informational
2 findingsgenerate_codeINFOChangedload_spec_from_fileINFOChanged
What do these results mean?
- PASS
- No policy-significant interface change detected.
- REVIEW
- Interface changes require inspection.
- FAIL
- A policy-significant change was detected.
- INVALID
- The comparison could not be evaluated reliably.