@autobe/agent 0.3.22 → 0.3.23

package/lib/index.mjs

@@ -50,24 +50,6 @@ function assertSchemaModel(model) {
     if (model === "gemini") throw new Error([ "Error on AutoBeAgent.constructor(): gemini is not supported", "because it does not follow standard JSON schema specification.", "@autobe requires union type (`oneOf` or `anyOf`) for backend code generation,", "but gemini has banned them. Please wait until when `@agentica`", "supports prompt based function calling which can detour gemini's", "restriction of JSON schema specification." ].join(" "));
 }
 
-function divideArray(props) {
-    if (props.capacity <= 0) {
-        throw new Error("Capacity must be a positive integer");
-    }
-    if (Number.isNaN(props.capacity)) {
-        throw new TypeError("Capacity must be a positive integer");
-    }
-    if (props.capacity === Infinity) {
-        throw new Error("Capacity must be a positive integer");
-    }
-    const size = Math.ceil(props.array.length / props.capacity);
-    const capacity = Math.ceil(props.array.length / size);
-    const replica = props.array.slice();
-    return Array.from({
-        length: size
-    }, (() => replica.splice(0, capacity)));
-}
-
 const transformInterfaceHistories = (state, systemMessage) => {
     if (state.analyze === null) return [ {
         type: "systemMessage",
@@ -90,10 +72,450 @@ const transformInterfaceHistories = (state, systemMessage) => {
         text: [ "Requirement analysis and Prisma DB schema generation are ready.", "", "Call the provided tool function to generate the OpenAPI document", "referencing below requirement analysis and Prisma DB schema.", "", `## User Request`, "", state.analyze.reason, "", `## Requirement Analysis Report`, "", "```json", JSON.stringify(state.analyze.files), "```" ].join("\n")
     }, {
         type: "assistantMessage",
-        text: [ "## Prisma DB Schema", "```json", JSON.stringify(state.prisma.result.schemas), "```", "", "## Entity Relationship Diagrams", "```json", JSON.stringify(state.prisma.result.diagrams), "```" ].join("\n")
+        text: [ "Database schema and entity relationship diagrams are ready.", "", "## Prisma DB Schema", "```json", JSON.stringify(state.prisma.result.schemas), "```", "", "## Entity Relationship Diagrams", "```json", JSON.stringify(state.prisma.result.diagrams), "```" ].join("\n")
     } ];
 };
 
+function orchestrateInterfaceComplement(ctx, document, retry = 8) {
+    return step$1(ctx, document, retry);
+}
+
+async function step$1(ctx, document, retry) {
+    const missed = getMissed(document);
+    if (missed.length === 0 || retry <= 0) return document.components;
+    const pointer = {
+        value: null
+    };
+    const agentica = new MicroAgentica({
+        model: ctx.model,
+        vendor: ctx.vendor,
+        config: {
+            ...ctx.config ?? {},
+            executor: {
+                describe: null
+            }
+        },
+        histories: [ ...transformInterfaceHistories(ctx.state(), '# OpenAPI Schema Complement Agent\n\nYou are an AI agent specialized in complementing missing schema definitions in OpenAPI documents. Your primary responsibility is to identify and fill in schema types that are referenced via `$ref` but not yet defined in the `components.schemas` section.\n\n## Your Role\n\nYou analyze OpenAPI documents to find missing schema definitions and generate complete, accurate JSON Schema definitions for those missing types. You work as part of a larger OpenAPI document generation workflow, specifically handling the final step of ensuring all referenced schemas are properly defined.\n\n## Key Responsibilities\n\n1. **Identify Missing Schemas**: Scan the OpenAPI document for `$ref` references pointing to `#/components/schemas/[ISchemaName]` that don\'t have corresponding definitions\n2. **Generate Schema Definitions**: Create complete JSON Schema definitions for missing types based on context clues from API operations, database schemas, and usage patterns\n3. **Handle Nested References**: When creating new schemas, identify any new `$ref` references introduced in those schemas and ensure they are also defined\n4. **Iterative Completion**: Continue the process recursively until all referenced schemas (including nested ones) are properly defined\n5. **Ensure Completeness**: Make sure all generated schemas follow JSON Schema specifications and are consistent with OpenAPI 3.0+ standards\n\n## Function Calling\n\nYou have access to the `complementComponents` function which you should call when you identify missing schemas:\n\n```typescript\ncomplementComponents({\n  schemas: {\n    ISchemaName: {\n      // Complete JSON Schema definition\n      description: "Description must be clear and detailed"\n    }\n  }\n})\n```\n\n## Guidelines for Schema Generation\n\n1. **Type Inference**: Infer appropriate types based on context (API operations, database fields, naming conventions)\n2. **Property Requirements**: Determine which properties should be required vs optional based on usage patterns\n3. **Data Formats**: Apply appropriate formats (email, date-time, uri, etc.) when evident from context\n4. **Nested References**: Handle schemas that reference other schemas appropriately\n5. **Validation Rules**: Include reasonable validation constraints (minLength, maxLength, pattern, etc.) when applicable\n6. **Recursive Schema Detection**: When creating new schemas, scan them for additional `$ref` references and ensure those referenced schemas are also created\n7. **Dependency Chain Completion**: Continue generating schemas until no more missing references exist in the entire schema dependency chain\n8. **Comprehensive Descriptions**: Add detailed, clear descriptions to every schema and property that explain:\n   - What the schema/property represents\n   - Its purpose and usage context\n   - Any business logic or constraints\n   - Examples of valid values when helpful\n   - Relationships to other entities or concepts\n\n## Response Format\n\n- Analyze the provided OpenAPI document systematically\n- Identify all missing schema references (including those in newly created schemas)\n- Generate appropriate schema definitions for all missing references\n- Recursively check for new `$ref` references introduced in generated schemas\n- Call the `complementComponents` function with all missing schemas (may require multiple calls if nested dependencies are discovered)\n- Provide a brief summary of what schemas were added and any dependency chains that were resolved\n\n## Quality Standards\n\n- Ensure all generated schemas are valid JSON Schema\n- Maintain consistency with existing schema patterns in the document\n- Use descriptive and clear property names\n- **Add comprehensive descriptions**: Every schema object and property must include detailed descriptions that are:\n  - Clear and understandable to anyone reading the API documentation\n  - Specific about the purpose and usage of each field\n  - Include examples or context when helpful\n  - Explain any business rules or constraints\n  - Describe relationships between different entities\n- Follow OpenAPI best practices for schema design\n- Make the API documentation self-explanatory through excellent descriptions\n\nFocus on accuracy, completeness, and maintaining the integrity of the OpenAPI specification.'), {
+            type: "assistantMessage",
+            text: [ "Here is the OpenAPI document what you've made:", "", "```json", JSON.stringify(document), "```" ].join("\n")
+        }, {
+            type: "assistantMessage",
+            text: [ "You have missed below schema types in the document.components.schemas:", "", ...missed.map((s => `- ${s}`)) ].join("\n")
+        } ],
+        tokenUsage: ctx.usage(),
+        controllers: [ createApplication$6({
+            model: ctx.model,
+            build: next => {
+                pointer.value = OpenApiV3_1Emender.convertComponents({
+                    schemas: next
+                }).schemas ?? {};
+            }
+        }) ]
+    });
+    agentica.on("request", (async event => {
+        event.body.tool_choice = "required";
+    }));
+    await agentica.conversate("Fill missing schema types please");
+    if (pointer.value === null) {
+        throw new Error("Failed to fill missing schema types. No response from agentica.");
+    }
+    ctx.dispatch({
+        type: "interfaceComplement",
+        missed,
+        schemas: pointer.value,
+        step: ctx.state().analyze?.step ?? 0,
+        created_at: (new Date).toISOString()
+    });
+    const newComponents = {
+        schemas: {
+            ...pointer.value,
+            ...document.components.schemas
+        },
+        authorization: document.components.authorization
+    };
+    return step$1(ctx, {
+        ...document,
+        components: newComponents
+    }, retry - 1);
+}
+
+const getMissed = document => {
+    const missed = new Set;
+    const check = name => {
+        if (document.components.schemas[name] === undefined) missed.add(name);
+    };
+    for (const op of document.operations) {
+        if (op.requestBody !== null) check(op.requestBody.typeName);
+        if (op.responseBody !== null) check(op.responseBody.typeName);
+    }
+    for (const value of Object.values(document.components.schemas)) OpenApiTypeChecker.visit({
+        components: document.components,
+        schema: value,
+        closure: next => {
+            if (OpenApiTypeChecker.isReference(next)) check(next.$ref.split("/").pop());
+        }
+    });
+    return Array.from(missed);
+};
+
+function createApplication$6(props) {
+    assertSchemaModel(props.model);
+    const application = collection$8[props.model];
+    return {
+        protocol: "class",
+        name: "interface",
+        application,
+        execute: {
+            complementComponents: next => {
+                props.build(next.schemas);
+            }
+        }
+    };
+}
+
+const claude$8 = {
+    model: "claude",
+    options: {
+        reference: true,
+        separate: null
+    },
+    functions: [ {
+        name: "complementComponents",
+        parameters: {
+            description: "Current Type: {@link IComplementComponentsProps}",
+            type: "object",
+            properties: {
+                schemas: {
+                    description: 'A collection of missing schema definitions that need to be added to the\nOpenAPI document\'s `components.schemas` section.\n\nThis object contains schema definitions for types that are referenced but\nnot yet defined:\n\n- Key: Schema name (`string`): The name of the schema type that will be\n  referenced in $ref statements\n- Value: `AutoBeOpenApi.IJsonSchema` - The complete JSON Schema definition\n  for that type\n\nExample structure:\n\n```typescript\n{\n  "UserProfile": {\n    "type": "object",\n    "properties": {\n      "id": { "type": "string" },\n      "name": { "type": "string" },\n      "email": { "type": "string", "format": "email" }\n    },\n    "required": ["id", "name", "email"]\n  }\n}\n```\n\nEach schema definition follows the JSON Schema specification and will be\ndirectly inserted into the OpenAPI document\'s components.schemas section,\nmaking them available for $ref references throughout the API\nspecification.\n\n------------------------------\n\nDescription of the current {@link RecordstringAutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema} type:\n\n> Construct a type with a set of properties K of type T',
+                    type: "object",
+                    properties: {},
+                    required: [],
+                    additionalProperties: {
+                        description: "Description of the current {@link AutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema} type:\n\n> Descriptive type schema info.\n> \n> `AutoBeOpenApi.IJsonSchemaDescriptive` is a type schema info of the OpenAPI\n> Generative, but it has a `description` property which is required.\n> \n> `AutoBeOpenApi.IJsonSchemaDescriptive` basically follows the JSON schema\n> specification of OpenAPI v3.1, but a little bit shrunk to remove ambiguous\n> and duplicated expressions of OpenAPI v3.1 for the convenience, clarity,\n> and AI generation.\n> \n> CRITICAL INSTRUCTIONS FOR OPTIMAL AI GENERATION:\n> \n> When creating descriptions for components, types, and properties:\n> \n> 1. ALWAYS refer to and incorporate the description comments from the\n>    corresponding Prisma DB schema tables and columns. The descriptions\n>    should match the style, level of detail, and terminology used in the\n>    Prisma schema.\n> 2. ALL descriptions MUST be organized into MULTIPLE PARAGRAPHS separated by\n>    line breaks. Single-paragraph descriptions should be avoided.\n> 3. Descriptions should comprehensively cover:\n> \n>    - The purpose and business meaning of the type or property\n>    - Relationships to other entities\n>    - Validation rules, constraints, and edge cases\n>    - Usage context and examples when helpful\n> 4. For each property of an object type, ensure its description reflects the\n>    corresponding column description in the Prisma DB schema, maintaining\n>    the same level of detail and terminology\n> 5. Descriptions should be so detailed and clear that anyone reading them can\n>    fully understand the type or property without needing to reference any\n>    other documentation",
+                        type: "object",
+                        properties: {
+                            description: {
+                                title: "Description about the type",
+                                description: "Description about the type.\n\nCRITICAL: This description MUST be extensively detailed and MUST\nreference and align with the description comments from the\ncorresponding Prisma DB schema tables and columns.\n\nThe description MUST be organized into MULTIPLE PARAGRAPHS (separated\nby line breaks) based on different aspects of the type:\n\n- The purpose and business meaning of the type\n- Relationships to other entities in the system\n- Validation rules, constraints, and edge cases\n- Usage context and examples when helpful\n\nThis structured approach improves readability and helps readers better\nunderstand the type's various characteristics and use cases. The\ndescription should be so comprehensive that anyone reading it can fully\nunderstand the type without needing to reference other documentation.\n\n> MUST be written in English. Never use other languages.",
+                                type: "string"
+                            }
+                        },
+                        required: [ "description" ]
+                    }
+                }
+            },
+            required: [ "schemas" ],
+            additionalProperties: false,
+            $defs: {}
+        },
+        description: 'Complements missing schema types\n\nThis method fills in schema definitions that are referenced via $ref but\nnot yet defined in the `components.schemas` section. For example, if an API\noperation references `{ "$ref": "#/components/schemas/UserProfile" }` but\n`UserProfile` type is not defined in `components.schemas`, this method will\nadd the missing schema definition.\n\nThis function is designed to be called via AI function calling mechanism to\nensure the OpenAPI document is complete and all referenced schemas are\nproperly defined.',
+        validate: (() => {
+            const _io0 = input => "object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) && _io1(input.schemas);
+            const _io1 = input => Object.keys(input).every((key => {
+                const value = input[key];
+                if (undefined === value) return true;
+                return "object" === typeof value && null !== value && _io2(value);
+            }));
+            const _io2 = input => "string" === typeof input.description;
+            const _vo0 = (input, _path, _exceptionable = true) => [ ("object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) || _report(_exceptionable, {
+                path: _path + ".schemas",
+                expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                value: input.schemas
+            })) && _vo1(input.schemas, _path + ".schemas", _exceptionable) || _report(_exceptionable, {
+                path: _path + ".schemas",
+                expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                value: input.schemas
+            }) ].every((flag => flag));
+            const _vo1 = (input, _path, _exceptionable = true) => [ false === _exceptionable || Object.keys(input).map((key => {
+                const value = input[key];
+                if (undefined === value) return true;
+                return ("object" === typeof value && null !== value || _report(_exceptionable, {
+                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                    expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
+                    value
+                })) && _vo2(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), _exceptionable) || _report(_exceptionable, {
+                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                    expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
+                    value
+                });
+            })).every((flag => flag)) ].every((flag => flag));
+            const _vo2 = (input, _path, _exceptionable = true) => [ "string" === typeof input.description || _report(_exceptionable, {
+                path: _path + ".description",
+                expected: "string",
+                value: input.description
+            }) ].every((flag => flag));
+            const __is = input => "object" === typeof input && null !== input && _io0(input);
+            let errors;
+            let _report;
+            return input => {
+                if (false === __is(input)) {
+                    errors = [];
+                    _report = __typia_transform__validateReport._validateReport(errors);
+                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                        path: _path + "",
+                        expected: "IComplementComponentsProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "IComplementComponentsProps",
+                        value: input
+                    }))(input, "$input", true);
+                    const success = 0 === errors.length;
+                    return success ? {
+                        success,
+                        data: input
+                    } : {
+                        success,
+                        errors,
+                        data: input
+                    };
+                }
+                return {
+                    success: true,
+                    data: input
+                };
+            };
+        })()
+    } ]
+};
+
+const collection$8 = {
+    chatgpt: {
+        model: "chatgpt",
+        options: {
+            reference: true,
+            strict: false,
+            separate: null
+        },
+        functions: [ {
+            name: "complementComponents",
+            parameters: {
+                description: "Current Type: {@link IComplementComponentsProps}",
+                type: "object",
+                properties: {
+                    schemas: {
+                        description: 'A collection of missing schema definitions that need to be added to the\nOpenAPI document\'s `components.schemas` section.\n\nThis object contains schema definitions for types that are referenced but\nnot yet defined:\n\n- Key: Schema name (`string`): The name of the schema type that will be\n  referenced in $ref statements\n- Value: `AutoBeOpenApi.IJsonSchema` - The complete JSON Schema definition\n  for that type\n\nExample structure:\n\n```typescript\n{\n  "UserProfile": {\n    "type": "object",\n    "properties": {\n      "id": { "type": "string" },\n      "name": { "type": "string" },\n      "email": { "type": "string", "format": "email" }\n    },\n    "required": ["id", "name", "email"]\n  }\n}\n```\n\nEach schema definition follows the JSON Schema specification and will be\ndirectly inserted into the OpenAPI document\'s components.schemas section,\nmaking them available for $ref references throughout the API\nspecification.\n\n------------------------------\n\nDescription of the current {@link RecordstringAutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema} type:\n\n> Construct a type with a set of properties K of type T',
+                        type: "object",
+                        properties: {},
+                        required: [],
+                        additionalProperties: {
+                            description: "Description of the current {@link AutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema} type:\n\n> Descriptive type schema info.\n> \n> `AutoBeOpenApi.IJsonSchemaDescriptive` is a type schema info of the OpenAPI\n> Generative, but it has a `description` property which is required.\n> \n> `AutoBeOpenApi.IJsonSchemaDescriptive` basically follows the JSON schema\n> specification of OpenAPI v3.1, but a little bit shrunk to remove ambiguous\n> and duplicated expressions of OpenAPI v3.1 for the convenience, clarity,\n> and AI generation.\n> \n> CRITICAL INSTRUCTIONS FOR OPTIMAL AI GENERATION:\n> \n> When creating descriptions for components, types, and properties:\n> \n> 1. ALWAYS refer to and incorporate the description comments from the\n>    corresponding Prisma DB schema tables and columns. The descriptions\n>    should match the style, level of detail, and terminology used in the\n>    Prisma schema.\n> 2. ALL descriptions MUST be organized into MULTIPLE PARAGRAPHS separated by\n>    line breaks. Single-paragraph descriptions should be avoided.\n> 3. Descriptions should comprehensively cover:\n> \n>    - The purpose and business meaning of the type or property\n>    - Relationships to other entities\n>    - Validation rules, constraints, and edge cases\n>    - Usage context and examples when helpful\n> 4. For each property of an object type, ensure its description reflects the\n>    corresponding column description in the Prisma DB schema, maintaining\n>    the same level of detail and terminology\n> 5. Descriptions should be so detailed and clear that anyone reading them can\n>    fully understand the type or property without needing to reference any\n>    other documentation",
+                            type: "object",
+                            properties: {
+                                description: {
+                                    title: "Description about the type",
+                                    description: "Description about the type.\n\nCRITICAL: This description MUST be extensively detailed and MUST\nreference and align with the description comments from the\ncorresponding Prisma DB schema tables and columns.\n\nThe description MUST be organized into MULTIPLE PARAGRAPHS (separated\nby line breaks) based on different aspects of the type:\n\n- The purpose and business meaning of the type\n- Relationships to other entities in the system\n- Validation rules, constraints, and edge cases\n- Usage context and examples when helpful\n\nThis structured approach improves readability and helps readers better\nunderstand the type's various characteristics and use cases. The\ndescription should be so comprehensive that anyone reading it can fully\nunderstand the type without needing to reference other documentation.\n\n> MUST be written in English. Never use other languages.",
+                                    type: "string"
+                                }
+                            },
+                            required: [ "description" ]
+                        }
+                    }
+                },
+                required: [ "schemas" ],
+                additionalProperties: false,
+                $defs: {}
+            },
+            description: 'Complements missing schema types\n\nThis method fills in schema definitions that are referenced via $ref but\nnot yet defined in the `components.schemas` section. For example, if an API\noperation references `{ "$ref": "#/components/schemas/UserProfile" }` but\n`UserProfile` type is not defined in `components.schemas`, this method will\nadd the missing schema definition.\n\nThis function is designed to be called via AI function calling mechanism to\nensure the OpenAPI document is complete and all referenced schemas are\nproperly defined.',
+            validate: (() => {
+                const _io0 = input => "object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) && _io1(input.schemas);
+                const _io1 = input => Object.keys(input).every((key => {
+                    const value = input[key];
+                    if (undefined === value) return true;
+                    return "object" === typeof value && null !== value && _io2(value);
+                }));
+                const _io2 = input => "string" === typeof input.description;
+                const _vo0 = (input, _path, _exceptionable = true) => [ ("object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) || _report(_exceptionable, {
+                    path: _path + ".schemas",
+                    expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                    value: input.schemas
+                })) && _vo1(input.schemas, _path + ".schemas", _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".schemas",
+                    expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                    value: input.schemas
+                }) ].every((flag => flag));
+                const _vo1 = (input, _path, _exceptionable = true) => [ false === _exceptionable || Object.keys(input).map((key => {
+                    const value = input[key];
+                    if (undefined === value) return true;
+                    return ("object" === typeof value && null !== value || _report(_exceptionable, {
+                        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                        expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
+                        value
+                    })) && _vo2(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), _exceptionable) || _report(_exceptionable, {
+                        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                        expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
+                        value
+                    });
+                })).every((flag => flag)) ].every((flag => flag));
+                const _vo2 = (input, _path, _exceptionable = true) => [ "string" === typeof input.description || _report(_exceptionable, {
+                    path: _path + ".description",
+                    expected: "string",
+                    value: input.description
+                }) ].every((flag => flag));
+                const __is = input => "object" === typeof input && null !== input && _io0(input);
+                let errors;
+                let _report;
+                return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "IComplementComponentsProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IComplementComponentsProps",
+                            value: input
+                        }))(input, "$input", true);
+                        const success = 0 === errors.length;
+                        return success ? {
+                            success,
+                            data: input
+                        } : {
+                            success,
+                            errors,
+                            data: input
+                        };
+                    }
+                    return {
+                        success: true,
+                        data: input
+                    };
+                };
+            })()
+        } ]
+    },
+    claude: claude$8,
+    llama: claude$8,
+    deepseek: claude$8,
+    3.1: claude$8,
+    "3.0": {
+        model: "3.0",
+        options: {
+            constraint: true,
+            recursive: 3,
+            separate: null
+        },
+        functions: [ {
+            name: "complementComponents",
+            parameters: {
+                type: "object",
+                properties: {
+                    schemas: {
+                        type: "object",
+                        properties: {},
+                        required: [],
+                        description: 'A collection of missing schema definitions that need to be added to the\nOpenAPI document\'s `components.schemas` section.\n\nThis object contains schema definitions for types that are referenced but\nnot yet defined:\n\n- Key: Schema name (`string`): The name of the schema type that will be\n  referenced in $ref statements\n- Value: `AutoBeOpenApi.IJsonSchema` - The complete JSON Schema definition\n  for that type\n\nExample structure:\n\n```typescript\n{\n  "UserProfile": {\n    "type": "object",\n    "properties": {\n      "id": { "type": "string" },\n      "name": { "type": "string" },\n      "email": { "type": "string", "format": "email" }\n    },\n    "required": ["id", "name", "email"]\n  }\n}\n```\n\nEach schema definition follows the JSON Schema specification and will be\ndirectly inserted into the OpenAPI document\'s components.schemas section,\nmaking them available for $ref references throughout the API\nspecification.\n\n------------------------------\n\nDescription of the current {@link RecordstringAutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema} type:\n\n> Construct a type with a set of properties K of type T',
+                        additionalProperties: {
+                            type: "object",
+                            properties: {
+                                description: {
+                                    type: "string",
+                                    title: "Description about the type",
+                                    description: "Description about the type.\n\nCRITICAL: This description MUST be extensively detailed and MUST\nreference and align with the description comments from the\ncorresponding Prisma DB schema tables and columns.\n\nThe description MUST be organized into MULTIPLE PARAGRAPHS (separated\nby line breaks) based on different aspects of the type:\n\n- The purpose and business meaning of the type\n- Relationships to other entities in the system\n- Validation rules, constraints, and edge cases\n- Usage context and examples when helpful\n\nThis structured approach improves readability and helps readers better\nunderstand the type's various characteristics and use cases. The\ndescription should be so comprehensive that anyone reading it can fully\nunderstand the type without needing to reference other documentation.\n\n> MUST be written in English. Never use other languages."
+                                }
+                            },
+                            required: [ "description" ],
+                            description: "Description of the current {@link AutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema} type:\n\n> Descriptive type schema info.\n> \n> `AutoBeOpenApi.IJsonSchemaDescriptive` is a type schema info of the OpenAPI\n> Generative, but it has a `description` property which is required.\n> \n> `AutoBeOpenApi.IJsonSchemaDescriptive` basically follows the JSON schema\n> specification of OpenAPI v3.1, but a little bit shrunk to remove ambiguous\n> and duplicated expressions of OpenAPI v3.1 for the convenience, clarity,\n> and AI generation.\n> \n> CRITICAL INSTRUCTIONS FOR OPTIMAL AI GENERATION:\n> \n> When creating descriptions for components, types, and properties:\n> \n> 1. ALWAYS refer to and incorporate the description comments from the\n>    corresponding Prisma DB schema tables and columns. The descriptions\n>    should match the style, level of detail, and terminology used in the\n>    Prisma schema.\n> 2. ALL descriptions MUST be organized into MULTIPLE PARAGRAPHS separated by\n>    line breaks. Single-paragraph descriptions should be avoided.\n> 3. Descriptions should comprehensively cover:\n> \n>    - The purpose and business meaning of the type or property\n>    - Relationships to other entities\n>    - Validation rules, constraints, and edge cases\n>    - Usage context and examples when helpful\n> 4. For each property of an object type, ensure its description reflects the\n>    corresponding column description in the Prisma DB schema, maintaining\n>    the same level of detail and terminology\n> 5. Descriptions should be so detailed and clear that anyone reading them can\n>    fully understand the type or property without needing to reference any\n>    other documentation",
+                            additionalProperties: false
+                        }
+                    }
+                },
+                required: [ "schemas" ],
+                description: "Current Type: {@link IComplementComponentsProps}",
+                additionalProperties: false
+            },
+            description: 'Complements missing schema types\n\nThis method fills in schema definitions that are referenced via $ref but\nnot yet defined in the `components.schemas` section. For example, if an API\noperation references `{ "$ref": "#/components/schemas/UserProfile" }` but\n`UserProfile` type is not defined in `components.schemas`, this method will\nadd the missing schema definition.\n\nThis function is designed to be called via AI function calling mechanism to\nensure the OpenAPI document is complete and all referenced schemas are\nproperly defined.',
+            validate: (() => {
+                const _io0 = input => "object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) && _io1(input.schemas);
+                const _io1 = input => Object.keys(input).every((key => {
+                    const value = input[key];
+                    if (undefined === value) return true;
+                    return "object" === typeof value && null !== value && _io2(value);
+                }));
+                const _io2 = input => "string" === typeof input.description;
+                const _vo0 = (input, _path, _exceptionable = true) => [ ("object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) || _report(_exceptionable, {
+                    path: _path + ".schemas",
+                    expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                    value: input.schemas
+                })) && _vo1(input.schemas, _path + ".schemas", _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".schemas",
+                    expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                    value: input.schemas
+                }) ].every((flag => flag));
+                const _vo1 = (input, _path, _exceptionable = true) => [ false === _exceptionable || Object.keys(input).map((key => {
+                    const value = input[key];
+                    if (undefined === value) return true;
+                    return ("object" === typeof value && null !== value || _report(_exceptionable, {
+                        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                        expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
+                        value
+                    })) && _vo2(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), _exceptionable) || _report(_exceptionable, {
+                        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                        expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
+                        value
+                    });
+                })).every((flag => flag)) ].every((flag => flag));
+                const _vo2 = (input, _path, _exceptionable = true) => [ "string" === typeof input.description || _report(_exceptionable, {
+                    path: _path + ".description",
+                    expected: "string",
+                    value: input.description
+                }) ].every((flag => flag));
+                const __is = input => "object" === typeof input && null !== input && _io0(input);
+                let errors;
+                let _report;
+                return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "IComplementComponentsProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IComplementComponentsProps",
+                            value: input
+                        }))(input, "$input", true);
+                        const success = 0 === errors.length;
+                        return success ? {
+                            success,
+                            data: input
+                        } : {
+                            success,
+                            errors,
+                            data: input
+                        };
+                    }
+                    return {
+                        success: true,
+                        data: input
+                    };
+                };
+            })()
+        } ]
+    }
+};
+
+function divideArray(props) {
+    if (props.capacity <= 0) {
+        throw new Error("Capacity must be a positive integer");
+    }
+    if (Number.isNaN(props.capacity)) {
+        throw new TypeError("Capacity must be a positive integer");
+    }
+    if (props.capacity === Infinity) {
+        throw new Error("Capacity must be a positive integer");
+    }
+    const size = Math.ceil(props.array.length / props.capacity);
+    const capacity = Math.ceil(props.array.length / size);
+    const replica = props.array.slice();
+    return Array.from({
+        length: size
+    }, (() => replica.splice(0, capacity)));
+}
+
 async function orchestrateInterfaceComponents(ctx, operations, capacity = 12) {
     const typeNames = new Set;
     for (const op of operations) {
@@ -186,115 +608,6 @@ async function process$2(ctx, operations, oldbie, remained) {
 function createApplication$5(props) {
     assertSchemaModel(props.model);
     const application = collection$7[props.model];
-    const validate = next => {
-        const result = (() => {
-            const _io0 = input => "object" === typeof input.components && null !== input.components && _io1(input.components);
-            const _io1 = input => "object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) && _io2(input.schemas) && (undefined === input.authorization || "header" === input.authorization);
-            const _io2 = input => Object.keys(input).every((key => {
-                const value = input[key];
-                if (undefined === value) return true;
-                return "object" === typeof value && null !== value && _io3(value);
-            }));
-            const _io3 = input => "string" === typeof input.description;
-            const _vo0 = (input, _path, _exceptionable = true) => [ ("object" === typeof input.components && null !== input.components || _report(_exceptionable, {
-                path: _path + ".components",
-                expected: "AutoBeOpenApi.IComponents",
-                value: input.components
-            })) && _vo1(input.components, _path + ".components", _exceptionable) || _report(_exceptionable, {
-                path: _path + ".components",
-                expected: "AutoBeOpenApi.IComponents",
-                value: input.components
-            }) ].every((flag => flag));
-            const _vo1 = (input, _path, _exceptionable = true) => [ ("object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) || _report(_exceptionable, {
-                path: _path + ".schemas",
-                expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
-                value: input.schemas
-            })) && _vo2(input.schemas, _path + ".schemas", _exceptionable) || _report(_exceptionable, {
-                path: _path + ".schemas",
-                expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
-                value: input.schemas
-            }), undefined === input.authorization || "header" === input.authorization || _report(_exceptionable, {
-                path: _path + ".authorization",
-                expected: '("header" | undefined)',
-                value: input.authorization
-            }) ].every((flag => flag));
-            const _vo2 = (input, _path, _exceptionable = true) => [ false === _exceptionable || Object.keys(input).map((key => {
-                const value = input[key];
-                if (undefined === value) return true;
-                return ("object" === typeof value && null !== value || _report(_exceptionable, {
-                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-                    expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
-                    value
-                })) && _vo3(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), _exceptionable) || _report(_exceptionable, {
-                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
-                    expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
-                    value
-                });
-            })).every((flag => flag)) ].every((flag => flag));
-            const _vo3 = (input, _path, _exceptionable = true) => [ "string" === typeof input.description || _report(_exceptionable, {
-                path: _path + ".description",
-                expected: "string",
-                value: input.description
-            }) ].every((flag => flag));
-            const __is = input => "object" === typeof input && null !== input && _io0(input);
-            let errors;
-            let _report;
-            return input => {
-                if (false === __is(input)) {
-                    errors = [];
-                    _report = __typia_transform__validateReport._validateReport(errors);
-                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                        path: _path + "",
-                        expected: "IMakeComponentsProps",
-                        value: input
-                    })) && _vo0(input, _path + "", true) || _report(true, {
-                        path: _path + "",
-                        expected: "IMakeComponentsProps",
-                        value: input
-                    }))(input, "$input", true);
-                    const success = 0 === errors.length;
-                    return success ? {
-                        success,
-                        data: input
-                    } : {
-                        success,
-                        errors,
-                        data: input
-                    };
-                }
-                return {
-                    success: true,
-                    data: input
-                };
-            };
-        })()(next);
-        if (result.success === false) return result;
-        props.pointer.value = result.data.components;
-        const errors = [];
-        for (const value of Object.values(result.data.components.schemas)) {
-            OpenApiTypeChecker.visit({
-                components: result.data.components,
-                schema: value,
-                closure: v => {
-                    if (OpenApiTypeChecker.isReference(v)) {
-                        const key = v.$ref.split("/").at(-1);
-                        if (result.data.components.schemas?.[key] === undefined) errors.push({
-                            path: `components.schemas.${key}`,
-                            expected: "AutoBeOpenApi.IJsonSchemaDescriptive",
-                            value: "undefined"
-                        });
-                    }
-                }
-            });
-        }
-        if (errors.length !== 0) return {
-            success: false,
-            data: result.data,
-            errors
-        };
-        return result;
-    };
-    application.functions[0].validate = validate;
     return {
         protocol: "class",
         name: "interface",
@@ -302,9 +615,6 @@ function createApplication$5(props) {
         execute: {
             makeComponents: async next => {
                 await props.build(next.components);
-                return {
-                    success: true
-                };
             }
         }
     };
@@ -323,7 +633,7 @@ const claude$7 = {
             type: "object",
             properties: {
                 components: {
-                    description: 'Complete set of schema components for the OpenAPI specification.\n\nThis property contains comprehensive type definitions for all entities in\nthe system. It is the central repository of all named schema types that\nwill be used throughout the API specification.\n\nCRITICAL REQUIREMENT: All object types MUST be defined as named types in\nthe components.schemas section. Inline anonymous object definitions are\nstrictly prohibited.\n\nThis components object should include:\n\n- Main entity types (IEntityName)\n- Operation-specific variants (.ICreate, .IUpdate, .ISummary, etc.)\n- Container types (IPage<T> for pagination)\n- Enumeration types\n\nAll schema definitions must include detailed descriptions that reference\nthe original Prisma schema comments and thoroughly document each property.\nEvery property that references an object must use a $ref to a named type in\nthe components.schemas section. This applies to all objects in request\nbodies, response bodies, and properties that are objects or arrays of\nobjects.\n\nExample structure:\n\n    components: {\n      schemas: {\n        IUser: {\n          type: "object",\n          properties: {\n            id: { type: "string", format: "uuid" },\n            email: { type: "string", format: "email" },\n            profile: { "$ref": "#/components/schemas/IUserProfile" }\n          },\n          required: ["id", "email"],\n          description: "User entity representing system account holders..."\n        },\n        "IUser.ICreate": { ... },\n        // Additional schemas\n      }\n    }\n\n------------------------------\n\nDescription of the current {@link AutoBeOpenApi.IComponents} type:\n\n> Reusable components in OpenAPI.\n> \n> A storage of reusable components in OpenAPI document.\n> \n> In other words, it is a storage of named DTO schemas and security schemes.',
+                    description: 'Complete set of schema components for the OpenAPI specification.\n\nThis property contains comprehensive type definitions for all entities in\nthe system. It is the central repository of all named schema types that\nwill be used throughout the API specification.\n\nCRITICAL REQUIREMENT: All object types MUST be defined as named types in\nthe components.schemas section. Inline anonymous object definitions are\nstrictly prohibited.\n\nThis components object should include:\n\n- Main entity types (IEntityName)\n- Operation-specific variants (.ICreate, .IUpdate, .ISummary, etc.)\n- Container types (IPage<T> for pagination)\n- Enumeration types\n\nAll schema definitions must include detailed descriptions that reference\nthe original Prisma schema comments and thoroughly document each property.\nEvery property that references an object must use a $ref to a named type in\nthe components.schemas section. This applies to all objects in request\nbodies, response bodies, and properties that are objects or arrays of\nobjects.\n\nExample structure:\n\n```typescript\n{\n  components: {\n    schemas: {\n      IUser: {\n        type: "object",\n        properties: {\n          id: { type: "string", format: "uuid" },\n          email: { type: "string", format: "email" },\n          profile: { "$ref": "#/components/schemas/IUserProfile" }\n        },\n        required: ["id", "email"],\n        description: "User entity representing system account holders..."\n      },\n      "IUser.ICreate": { ... },\n      // Additional schemas\n    }\n  }\n}\n```\n\n------------------------------\n\nDescription of the current {@link AutoBeOpenApi.IComponents} type:\n\n> Reusable components in OpenAPI.\n> \n> A storage of reusable components in OpenAPI document.\n> \n> In other words, it is a storage of named DTO schemas and security schemes.',
                     type: "object",
                     properties: {
                         schemas: {
@@ -457,7 +767,7 @@ const collection$7 = {
                 type: "object",
                 properties: {
                     components: {
-                        description: 'Complete set of schema components for the OpenAPI specification.\n\nThis property contains comprehensive type definitions for all entities in\nthe system. It is the central repository of all named schema types that\nwill be used throughout the API specification.\n\nCRITICAL REQUIREMENT: All object types MUST be defined as named types in\nthe components.schemas section. Inline anonymous object definitions are\nstrictly prohibited.\n\nThis components object should include:\n\n- Main entity types (IEntityName)\n- Operation-specific variants (.ICreate, .IUpdate, .ISummary, etc.)\n- Container types (IPage<T> for pagination)\n- Enumeration types\n\nAll schema definitions must include detailed descriptions that reference\nthe original Prisma schema comments and thoroughly document each property.\nEvery property that references an object must use a $ref to a named type in\nthe components.schemas section. This applies to all objects in request\nbodies, response bodies, and properties that are objects or arrays of\nobjects.\n\nExample structure:\n\n    components: {\n      schemas: {\n        IUser: {\n          type: "object",\n          properties: {\n            id: { type: "string", format: "uuid" },\n            email: { type: "string", format: "email" },\n            profile: { "$ref": "#/components/schemas/IUserProfile" }\n          },\n          required: ["id", "email"],\n          description: "User entity representing system account holders..."\n        },\n        "IUser.ICreate": { ... },\n        // Additional schemas\n      }\n    }\n\n------------------------------\n\nDescription of the current {@link AutoBeOpenApi.IComponents} type:\n\n> Reusable components in OpenAPI.\n> \n> A storage of reusable components in OpenAPI document.\n> \n> In other words, it is a storage of named DTO schemas and security schemes.',
+                        description: 'Complete set of schema components for the OpenAPI specification.\n\nThis property contains comprehensive type definitions for all entities in\nthe system. It is the central repository of all named schema types that\nwill be used throughout the API specification.\n\nCRITICAL REQUIREMENT: All object types MUST be defined as named types in\nthe components.schemas section. Inline anonymous object definitions are\nstrictly prohibited.\n\nThis components object should include:\n\n- Main entity types (IEntityName)\n- Operation-specific variants (.ICreate, .IUpdate, .ISummary, etc.)\n- Container types (IPage<T> for pagination)\n- Enumeration types\n\nAll schema definitions must include detailed descriptions that reference\nthe original Prisma schema comments and thoroughly document each property.\nEvery property that references an object must use a $ref to a named type in\nthe components.schemas section. This applies to all objects in request\nbodies, response bodies, and properties that are objects or arrays of\nobjects.\n\nExample structure:\n\n```typescript\n{\n  components: {\n    schemas: {\n      IUser: {\n        type: "object",\n        properties: {\n          id: { type: "string", format: "uuid" },\n          email: { type: "string", format: "email" },\n          profile: { "$ref": "#/components/schemas/IUserProfile" }\n        },\n        required: ["id", "email"],\n        description: "User entity representing system account holders..."\n      },\n      "IUser.ICreate": { ... },\n      // Additional schemas\n    }\n  }\n}\n```\n\n------------------------------\n\nDescription of the current {@link AutoBeOpenApi.IComponents} type:\n\n> Reusable components in OpenAPI.\n> \n> A storage of reusable components in OpenAPI document.\n> \n> In other words, it is a storage of named DTO schemas and security schemes.',
                         type: "object",
                         properties: {
                             schemas: {
@@ -622,7 +932,7 @@ const collection$7 = {
                             }
                         },
                         required: [ "schemas" ],
-                        description: 'Complete set of schema components for the OpenAPI specification.\n\nThis property contains comprehensive type definitions for all entities in\nthe system. It is the central repository of all named schema types that\nwill be used throughout the API specification.\n\nCRITICAL REQUIREMENT: All object types MUST be defined as named types in\nthe components.schemas section. Inline anonymous object definitions are\nstrictly prohibited.\n\nThis components object should include:\n\n- Main entity types (IEntityName)\n- Operation-specific variants (.ICreate, .IUpdate, .ISummary, etc.)\n- Container types (IPage<T> for pagination)\n- Enumeration types\n\nAll schema definitions must include detailed descriptions that reference\nthe original Prisma schema comments and thoroughly document each property.\nEvery property that references an object must use a $ref to a named type in\nthe components.schemas section. This applies to all objects in request\nbodies, response bodies, and properties that are objects or arrays of\nobjects.\n\nExample structure:\n\n    components: {\n      schemas: {\n        IUser: {\n          type: "object",\n          properties: {\n            id: { type: "string", format: "uuid" },\n            email: { type: "string", format: "email" },\n            profile: { "$ref": "#/components/schemas/IUserProfile" }\n          },\n          required: ["id", "email"],\n          description: "User entity representing system account holders..."\n        },\n        "IUser.ICreate": { ... },\n        // Additional schemas\n      }\n    }\n\n------------------------------\n\nDescription of the current {@link AutoBeOpenApi.IComponents} type:\n\n> Reusable components in OpenAPI.\n> \n> A storage of reusable components in OpenAPI document.\n> \n> In other words, it is a storage of named DTO schemas and security schemes.',
+                        description: 'Complete set of schema components for the OpenAPI specification.\n\nThis property contains comprehensive type definitions for all entities in\nthe system. It is the central repository of all named schema types that\nwill be used throughout the API specification.\n\nCRITICAL REQUIREMENT: All object types MUST be defined as named types in\nthe components.schemas section. Inline anonymous object definitions are\nstrictly prohibited.\n\nThis components object should include:\n\n- Main entity types (IEntityName)\n- Operation-specific variants (.ICreate, .IUpdate, .ISummary, etc.)\n- Container types (IPage<T> for pagination)\n- Enumeration types\n\nAll schema definitions must include detailed descriptions that reference\nthe original Prisma schema comments and thoroughly document each property.\nEvery property that references an object must use a $ref to a named type in\nthe components.schemas section. This applies to all objects in request\nbodies, response bodies, and properties that are objects or arrays of\nobjects.\n\nExample structure:\n\n```typescript\n{\n  components: {\n    schemas: {\n      IUser: {\n        type: "object",\n        properties: {\n          id: { type: "string", format: "uuid" },\n          email: { type: "string", format: "email" },\n          profile: { "$ref": "#/components/schemas/IUserProfile" }\n        },\n        required: ["id", "email"],\n        description: "User entity representing system account holders..."\n      },\n      "IUser.ICreate": { ... },\n      // Additional schemas\n    }\n  }\n}\n```\n\n------------------------------\n\nDescription of the current {@link AutoBeOpenApi.IComponents} type:\n\n> Reusable components in OpenAPI.\n> \n> A storage of reusable components in OpenAPI document.\n> \n> In other words, it is a storage of named DTO schemas and security schemes.',
                         additionalProperties: false
                     }
                 },
@@ -747,7 +1057,7 @@ async function orchestrateInterfaceEndpoints(ctx, content = "Make API endpoints
         tokenUsage: ctx.usage(),
         controllers: [ createApplication$4({
             model: ctx.model,
-            build: async endpoints => {
+            build: endpoints => {
                 pointer.value = endpoints;
             }
         }) ]
@@ -775,11 +1085,8 @@ function createApplication$4(props) {
         name: "interface",
         application,
         execute: {
-            makeEndpoints: async next => {
-                await props.build(next.endpoints);
-                return {
-                    success: true
-                };
+            makeEndpoints: next => {
+                props.build(next.endpoints);
             }
         }
     };
@@ -1172,7 +1479,7 @@ async function process$1(ctx, endpoints) {
         tokenUsage: ctx.usage(),
         controllers: [ createApplication$3({
             model: ctx.model,
-            build: async endpoints => {
+            build: endpoints => {
                 pointer.value = endpoints;
             },
             pointer
@@ -1471,11 +1778,8 @@ function createApplication$3(props) {
         name: "interface",
         application,
         execute: {
-            makeOperations: async next => {
-                await props.build(next.operations);
-                return {
-                    success: true
-                };
+            makeOperations: next => {
+                props.build(next.operations);
             }
         }
     };
@@ -3015,11 +3319,11 @@ const orchestrateInterface = ctx => async props => {
         return init;
     } else ctx.dispatch(init);
     const operations = await orchestrateInterfaceOperations(ctx, init.endpoints);
-    const components = await orchestrateInterfaceComponents(ctx, operations);
     const document = {
         operations,
-        components
+        components: await orchestrateInterfaceComponents(ctx, operations)
     };
+    document.components = await orchestrateInterfaceComplement(ctx, document);
     const result = {
         type: "interface",
         id: v4(),
@@ -4015,11 +4319,11 @@ const transformPrismaCompilerHistories = (files, result) => [ {
 } ];
 
 function orchestratePrismaCompiler(ctx, files, retry = 8) {
-    files["main.prisma"] = MAIN_PRISMA_FILE;
     return step(ctx, files, retry);
 }
 
 async function step(ctx, files, life) {
+    files["main.prisma"] = MAIN_PRISMA_FILE;
     const result = await ctx.compiler.prisma({
         files
     });