@autobe/agent 0.17.1 → 0.19.1

package/lib/agent/src/orchestrate/interface/orchestrateInterfaceSchemasReview.js

@@ -0,0 +1,473 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orchestrateInterfaceSchemasReview = orchestrateInterfaceSchemasReview;
+const __typia_transform__accessExpressionAsString = __importStar(require("typia/lib/internal/_accessExpressionAsString.js"));
+const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
+const __typia_transform__llmApplicationFinalize = __importStar(require("typia/lib/internal/_llmApplicationFinalize.js"));
+const OpenApiV3_1Emender_1 = require("@samchon/openapi/lib/converters/OpenApiV3_1Emender");
+const typia_1 = __importDefault(require("typia"));
+const assertSchemaModel_1 = require("../../context/assertSchemaModel");
+const transformInterfaceSchemasReviewHistories_1 = require("./histories/transformInterfaceSchemasReviewHistories");
+const validateAuthorizationSchema_1 = require("./utils/validateAuthorizationSchema");
+function orchestrateInterfaceSchemasReview(ctx, operations, schemas, progress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        try {
+            const pointer = {
+                value: null,
+            };
+            const { tokenUsage } = yield ctx.conversate({
+                source: "interfaceSchemasReview",
+                controller: createController({
+                    model: ctx.model,
+                    pointer,
+                    schemas,
+                }),
+                histories: (0, transformInterfaceSchemasReviewHistories_1.transformInterfaceSchemasReviewHistories)(ctx.state(), operations, schemas),
+                enforceFunctionCall: true,
+                message: "Review type schemas.",
+            });
+            if (pointer.value === null) {
+                console.error("Failed to extract review information.");
+                ++progress.completed;
+                return {};
+            }
+            const content = (_a = OpenApiV3_1Emender_1.OpenApiV3_1Emender.convertComponents({
+                schemas: pointer.value.content,
+            }).schemas) !== null && _a !== void 0 ? _a : {};
+            ctx.dispatch({
+                type: "interfaceSchemasReview",
+                schemas: schemas,
+                review: pointer.value.review,
+                plan: pointer.value.plan,
+                content,
+                tokenUsage,
+                step: (_c = (_b = ctx.state().analyze) === null || _b === void 0 ? void 0 : _b.step) !== null && _c !== void 0 ? _c : 0,
+                total: progress.total,
+                completed: ++progress.completed,
+                created_at: new Date().toISOString(),
+            });
+            return content;
+        }
+        catch (error) {
+            console.error("Error occurred during interface schemas review:", error);
+            ++progress.completed;
+            return {};
+        }
+    });
+}
+function createController(props) {
+    (0, assertSchemaModel_1.assertSchemaModel)(props.model);
+    const validate = (next) => {
+        const result = (() => { const _io0 = input => "string" === typeof input.review && "string" === typeof input.plan && ("object" === typeof input.content && null !== input.content && false === Array.isArray(input.content) && _io1(input.content)); 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) => ["string" === typeof input.review || _report(_exceptionable, {
+                path: _path + ".review",
+                expected: "string",
+                value: input.review
+            }), "string" === typeof input.plan || _report(_exceptionable, {
+                path: _path + ".plan",
+                expected: "string",
+                value: input.plan
+            }), ("object" === typeof input.content && null !== input.content && false === Array.isArray(input.content) || _report(_exceptionable, {
+                path: _path + ".content",
+                expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                value: input.content
+            })) && _vo1(input.content, _path + ".content", true && _exceptionable) || _report(_exceptionable, {
+                path: _path + ".content",
+                expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                value: input.content
+            })].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: value
+                })) && _vo2(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                    expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
+                    value: 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: "IAutoBeInterfaceSchemasReviewApplication.IProps",
+                    value: input
+                })) && _vo0(input, _path + "", true) || _report(true, {
+                    path: _path + "",
+                    expected: "IAutoBeInterfaceSchemasReviewApplication.IProps",
+                    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;
+        const errors = [];
+        (0, validateAuthorizationSchema_1.validateAuthorizationSchema)({
+            errors,
+            schemas: result.data.content,
+            path: "$input.content",
+        });
+        if (errors.length !== 0)
+            return {
+                success: false,
+                errors,
+                data: next,
+            };
+        return result;
+    };
+    const application = collection[props.model === "chatgpt" ? "chatgpt" : "claude"](validate);
+    return {
+        protocol: "class",
+        name: "Reviewer",
+        application,
+        execute: {
+            review: (input) => {
+                props.pointer.value = input;
+            },
+        },
+    };
+}
+const collection = {
+    chatgpt: (validate) => (() => {
+        const application = {
+            model: "chatgpt",
+            options: {
+                reference: true,
+                strict: false,
+                separate: null
+            },
+            functions: [
+                {
+                    name: "review",
+                    parameters: {
+                        description: " Contains review findings, improvement plan, and enhanced\nschemas\n\n------------------------------\n\nDescription of the current {@link IAutoBeInterfaceSchemasReviewApplication.IProps} type:\n\n> Schema review and enhancement parameters for the review function.\n> \n> When the review function is called, these properties must be populated to\n> complete the schema validation and improvement process. The LLM uses this\n> interface to understand what outputs are required.\n\n### Description of {@link content} property:\n\n> Final validated and enhanced schemas ready for production use.\n> \n> DO:\n> - Include valid OpenAPI schema definitions\n> - Include all entities that were in the original input\n> - Provide fixed versions if original schemas have issues\n> - Rename entities correctly if names are wrong\n> - Include created variants if schemas are missing them\n> \n> DO NOT:\n> - Return an empty object {} (this will delete all schemas)\n> - Return undefined or null\n> - Include explanations or excuses in schema descriptions\n> - Leave broken schemas unfixed\n> \n> When original schemas are beyond repair, recreate them properly based on\n> entity names and context. This field becomes the final schemas used by\n> the system, so it must always contain complete, valid schemas.",
+                        type: "object",
+                        properties: {
+                            review: {
+                                description: "Issues and problems found during schema analysis.\n\nDO: Document only problems that need fixing.\nDO NOT: Include positive feedback, compliments, or confirmations\n\nFocus exclusively on issues organized by severity:\n\nSeverity levels:\n- Security vulnerabilities (exposed passwords, missing auth boundaries)\n- Missing required variants, incorrect type mappings\n- Missing format specifications, incomplete relationships\n- Documentation improvements, style consistency\n\nEach issue must include the specific schema name and what needs to be\nfixed. If there are no issues at all, simply state: \"No issues found.\"",
+                                type: "string"
+                            },
+                            plan: {
+                                description: "Action plan for addressing identified issues.\n\nMust specify concrete fixes categorized by priority:\n\n- For perfect schemas: \"No improvements required. All schemas meet AutoBE\n  standards.\"\n- For fixable issues: List each fix with operation path and exact change\n- For critical problems: Describe how schemas were recreated or corrected\n\nNever leave this empty. Always provide a clear plan even if no changes\nare needed. The plan documents what was done to produce the content\nfield.",
+                                type: "string"
+                            },
+                            content: {
+                                $ref: "#/$defs/RecordstringAutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema"
+                            }
+                        },
+                        required: [
+                            "review",
+                            "plan",
+                            "content"
+                        ],
+                        additionalProperties: false,
+                        $defs: {
+                            "RecordstringAutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema": {
+                                description: "Construct a type with a set of properties K of type T",
+                                type: "object",
+                                properties: {},
+                                required: [],
+                                additionalProperties: {
+                                    $ref: "#/$defs/AutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema"
+                                }
+                            },
+                            "AutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema": {
+                                description: "Descriptive type schema info.\n\n`AutoBeOpenApi.IJsonSchemaDescriptive` is a type schema info of the OpenAPI\nGenerative, but it has a `description` property which is required.\n\n`AutoBeOpenApi.IJsonSchemaDescriptive` basically follows the JSON schema\nspecification of OpenAPI v3.1, but a little bit shrunk to remove ambiguous\nand duplicated expressions of OpenAPI v3.1 for the convenience, clarity,\nand AI generation.\n\nCRITICAL INSTRUCTIONS FOR OPTIMAL AI GENERATION:\n\nWhen creating descriptions for components, types, and properties:\n\n1. 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.\n2. ALL descriptions MUST be organized into MULTIPLE PARAGRAPHS separated by\n   line breaks. Single-paragraph descriptions should be avoided.\n3. 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\n4. 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\n5. 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: {
+                                        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"
+                                ]
+                            }
+                        }
+                    },
+                    description: "Analyzes and improves OpenAPI schema definitions.\n\nThis function receives schema definitions and performs comprehensive review\nand enhancement. It identifies issues, creates an improvement plan, and\nproduces refined schemas that meet quality standards.\n\nThe function populates three key outputs:\n\n- A detailed review of findings organized by severity\n- An actionable plan for improvements\n- Enhanced schemas with all issues resolved",
+                    validate: (() => { const _io0 = input => "string" === typeof input.review && "string" === typeof input.plan && ("object" === typeof input.content && null !== input.content && false === Array.isArray(input.content) && _io1(input.content)); 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) => ["string" === typeof input.review || _report(_exceptionable, {
+                            path: _path + ".review",
+                            expected: "string",
+                            value: input.review
+                        }), "string" === typeof input.plan || _report(_exceptionable, {
+                            path: _path + ".plan",
+                            expected: "string",
+                            value: input.plan
+                        }), ("object" === typeof input.content && null !== input.content && false === Array.isArray(input.content) || _report(_exceptionable, {
+                            path: _path + ".content",
+                            expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                            value: input.content
+                        })) && _vo1(input.content, _path + ".content", true && _exceptionable) || _report(_exceptionable, {
+                            path: _path + ".content",
+                            expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                            value: input.content
+                        })].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: value
+                            })) && _vo2(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || _report(_exceptionable, {
+                                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                                expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
+                                value: 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: "IAutoBeInterfaceSchemasReviewApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeInterfaceSchemasReviewApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
+                            data: input
+                        };
+                    }; })()
+                }
+            ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, Object.assign(Object.assign({}, {
+            validate: {
+                review: validate,
+            },
+        }), { equals: false }));
+        return application;
+    })(),
+    claude: (validate) => (() => {
+        const application = {
+            model: "claude",
+            options: {
+                reference: true,
+                separate: null
+            },
+            functions: [
+                {
+                    name: "review",
+                    parameters: {
+                        description: " Contains review findings, improvement plan, and enhanced\nschemas\n\n------------------------------\n\nDescription of the current {@link IAutoBeInterfaceSchemasReviewApplication.IProps} type:\n\n> Schema review and enhancement parameters for the review function.\n> \n> When the review function is called, these properties must be populated to\n> complete the schema validation and improvement process. The LLM uses this\n> interface to understand what outputs are required.",
+                        type: "object",
+                        properties: {
+                            review: {
+                                description: "Issues and problems found during schema analysis.\n\nDO: Document only problems that need fixing.\nDO NOT: Include positive feedback, compliments, or confirmations\n\nFocus exclusively on issues organized by severity:\n\nSeverity levels:\n- Security vulnerabilities (exposed passwords, missing auth boundaries)\n- Missing required variants, incorrect type mappings\n- Missing format specifications, incomplete relationships\n- Documentation improvements, style consistency\n\nEach issue must include the specific schema name and what needs to be\nfixed. If there are no issues at all, simply state: \"No issues found.\"",
+                                type: "string"
+                            },
+                            plan: {
+                                description: "Action plan for addressing identified issues.\n\nMust specify concrete fixes categorized by priority:\n\n- For perfect schemas: \"No improvements required. All schemas meet AutoBE\n  standards.\"\n- For fixable issues: List each fix with operation path and exact change\n- For critical problems: Describe how schemas were recreated or corrected\n\nNever leave this empty. Always provide a clear plan even if no changes\nare needed. The plan documents what was done to produce the content\nfield.",
+                                type: "string"
+                            },
+                            content: {
+                                description: "Final validated and enhanced schemas ready for production use.\n\nDO:\n- Include valid OpenAPI schema definitions\n- Include all entities that were in the original input\n- Provide fixed versions if original schemas have issues\n- Rename entities correctly if names are wrong\n- Include created variants if schemas are missing them\n\nDO NOT:\n- Return an empty object {} (this will delete all schemas)\n- Return undefined or null\n- Include explanations or excuses in schema descriptions\n- Leave broken schemas unfixed\n\nWhen original schemas are beyond repair, recreate them properly based on\nentity names and context. This field becomes the final schemas used by\nthe system, so it must always contain complete, valid schemas.",
+                                $ref: "#/$defs/RecordstringAutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema"
+                            }
+                        },
+                        required: [
+                            "review",
+                            "plan",
+                            "content"
+                        ],
+                        additionalProperties: false,
+                        $defs: {
+                            "RecordstringAutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema": {
+                                description: "Construct a type with a set of properties K of type T",
+                                type: "object",
+                                properties: {},
+                                required: [],
+                                additionalProperties: {
+                                    $ref: "#/$defs/AutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema"
+                                }
+                            },
+                            "AutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema": {
+                                description: "Descriptive type schema info.\n\n`AutoBeOpenApi.IJsonSchemaDescriptive` is a type schema info of the OpenAPI\nGenerative, but it has a `description` property which is required.\n\n`AutoBeOpenApi.IJsonSchemaDescriptive` basically follows the JSON schema\nspecification of OpenAPI v3.1, but a little bit shrunk to remove ambiguous\nand duplicated expressions of OpenAPI v3.1 for the convenience, clarity,\nand AI generation.\n\nCRITICAL INSTRUCTIONS FOR OPTIMAL AI GENERATION:\n\nWhen creating descriptions for components, types, and properties:\n\n1. 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.\n2. ALL descriptions MUST be organized into MULTIPLE PARAGRAPHS separated by\n   line breaks. Single-paragraph descriptions should be avoided.\n3. 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\n4. 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\n5. 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: {
+                                        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"
+                                ]
+                            }
+                        }
+                    },
+                    description: "Analyzes and improves OpenAPI schema definitions.\n\nThis function receives schema definitions and performs comprehensive review\nand enhancement. It identifies issues, creates an improvement plan, and\nproduces refined schemas that meet quality standards.\n\nThe function populates three key outputs:\n\n- A detailed review of findings organized by severity\n- An actionable plan for improvements\n- Enhanced schemas with all issues resolved",
+                    validate: (() => { const _io0 = input => "string" === typeof input.review && "string" === typeof input.plan && ("object" === typeof input.content && null !== input.content && false === Array.isArray(input.content) && _io1(input.content)); 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) => ["string" === typeof input.review || _report(_exceptionable, {
+                            path: _path + ".review",
+                            expected: "string",
+                            value: input.review
+                        }), "string" === typeof input.plan || _report(_exceptionable, {
+                            path: _path + ".plan",
+                            expected: "string",
+                            value: input.plan
+                        }), ("object" === typeof input.content && null !== input.content && false === Array.isArray(input.content) || _report(_exceptionable, {
+                            path: _path + ".content",
+                            expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                            value: input.content
+                        })) && _vo1(input.content, _path + ".content", true && _exceptionable) || _report(_exceptionable, {
+                            path: _path + ".content",
+                            expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                            value: input.content
+                        })].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: value
+                            })) && _vo2(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || _report(_exceptionable, {
+                                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                                expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
+                                value: 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: "IAutoBeInterfaceSchemasReviewApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeInterfaceSchemasReviewApplication.IProps",
+                                value: input
+                            }))(input, "$input", true);
+                            const success = 0 === errors.length;
+                            return success ? {
+                                success,
+                                data: input
+                            } : {
+                                success,
+                                errors,
+                                data: input
+                            };
+                        }
+                        return {
+                            success: true,
+                            data: input
+                        };
+                    }; })()
+                }
+            ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, Object.assign(Object.assign({}, {
+            validate: {
+                review: validate,
+            },
+        }), { equals: false }));
+        return application;
+    })(),
+};
+//# sourceMappingURL=orchestrateInterfaceSchemasReview.js.map

package/lib/agent/src/orchestrate/interface/orchestrateInterfaceSchemasReview.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrateInterfaceSchemasReview.js","sourceRoot":"","sources":["../../../../../src/orchestrate/interface/orchestrateInterfaceSchemasReview.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA,8EA6DC;;;;AAvED,2FAAwF;AAExF,kDAA0B;AAG1B,uEAAoE;AACpE,mHAAgH;AAEhH,qFAAkF;AAElF,SAAsB,iCAAiC,CAGrD,GAAyB,EACzB,UAAsC,EACtC,OAGC,EACD,QAA8C;;;QAE9C,IAAI,CAAC;YACH,MAAM,OAAO,GACX;gBACE,KAAK,EAAE,IAAI;aACZ,CAAC;YACJ,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;gBAC1C,MAAM,EAAE,wBAAwB;gBAChC,UAAU,EAAE,gBAAgB,CAAC;oBAC3B,KAAK,EAAE,GAAG,CAAC,KAAK;oBAChB,OAAO;oBACP,OAAO;iBACR,CAAC;gBACF,SAAS,EAAE,IAAA,mFAAwC,EACjD,GAAG,CAAC,KAAK,EAAE,EACX,UAAU,EACV,OAAO,CACR;gBACD,mBAAmB,EAAE,IAAI;gBACzB,OAAO,EAAE,sBAAsB;aAChC,CAAC,CAAC;YACH,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;gBAC3B,OAAO,CAAC,KAAK,CAAC,uCAAuC,CAAC,CAAC;gBACvD,EAAE,QAAQ,CAAC,SAAS,CAAC;gBACrB,OAAO,EAAE,CAAC;YACZ,CAAC;YAED,MAAM,OAAO,GACX,MACE,uCAAkB,CAAC,iBAAiB,CAAC;gBACnC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO;aAC/B,CACF,CAAC,OAAO,mCAAI,EAAE,CAAC;YAClB,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,wBAAwB;gBAC9B,OAAO,EAAE,OAAO;gBAChB,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,MAAM;gBAC5B,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,IAAI;gBACxB,OAAO;gBACP,UAAU;gBACV,IAAI,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC;gBACpC,KAAK,EAAE,QAAQ,CAAC,KAAK;gBACrB,SAAS,EAAE,EAAE,QAAQ,CAAC,SAAS;gBAC/B,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;aACO,CAAC,CAAC;YAC/C,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,iDAAiD,EAAE,KAAK,CAAC,CAAC;YACxE,EAAE,QAAQ,CAAC,SAAS,CAAC;YACrB,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;CAAA;AAED,SAAS,gBAAgB,CAAiC,KAOzD;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAE/B,MAAM,QAAQ,GAAG,CACf,IAAa,EACiD,EAAE;QAChE,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBACsD,IAAI,CAAC,CAAC;QACxE,IAAI,MAAM,CAAC,OAAO,KAAK,KAAK;YAAE,OAAO,MAAM,CAAC;QAE5C,MAAM,MAAM,GAAyB,EAAE,CAAC;QACxC,IAAA,yDAA2B,EAAC;YAC1B,MAAM;YACN,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO;YAC5B,IAAI,EAAE,gBAAgB;SACvB,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;YACrB,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,MAAM;gBACN,IAAI,EAAE,IAAI;aACX,CAAC;QACJ,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IACF,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CACjD,CACC,QAAQ,CAC2D,CAAC;IACtE,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,UAAU;QAChB,WAAW;QACX,OAAO,EAAE;YACP,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;gBAChB,KAAK,CAAC,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;YAC9B,CAAC;SACiD;KACrD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,GAAG;IACjB,OAAO,EAAE,CAAC,QAAmB,EAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uHAC4C;YACzE,QAAQ,EAAE;gBACR,MAAM,EAAE,QAAQ;aACjB;SACF;;QAAC;IACJ,MAAM,EAAE,CAAC,QAAmB,EAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uHAC4C;YACxE,QAAQ,EAAE;gBACR,MAAM,EAAE,QAAQ;aACjB;SACF;;QAAC;CACL,CAAC"}

package/lib/agent/src/orchestrate/interface/structures/IAutoBeInterfaceAuthorizationsApplication.d.ts

@@ -0,0 +1,47 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { tags } from "typia";
+export interface IAutoBeInterfaceAuthorizationsApplication {
+    /**
+     * Creates an authorization Operations for the given roles
+     *
+     * This method generates an OpenAPI interface that defines the authorization
+     * requirements for the given roles. It ensures that the interface reflects
+     * the correct permissions and access levels for each role.
+     */
+    makeOperations(props: IAutoBeInterfaceAuthorizationsApplication.IProps): void;
+}
+export declare namespace IAutoBeInterfaceAuthorizationsApplication {
+    interface IProps {
+        /**
+         * Array of API operations to generate authorization operation for.
+         *
+         * Each operation in this array must include:
+         *
+         * - Specification: Detailed API specification with clear purpose and
+         *   functionality
+         * - Path: Resource-centric URL path (e.g., "/resources/{resourceId}")
+         * - Method: HTTP method (get, post, put, delete, patch)
+         * - Description: Extremely detailed multi-paragraph description referencing
+         *   Prisma schema comments
+         * - Summary: Concise one-sentence summary of the endpoint
+         * - Parameters: Array of all necessary parameters with descriptions and
+         *   schema definitions
+         * - RequestBody: For POST/PUT/PATCH methods, with typeName referencing
+         *   components.schemas
+         * - ResponseBody: With typeName referencing appropriate response type
+         *
+         * All operations must follow strict quality standards:
+         *
+         * 1. Detailed descriptions referencing Prisma schema comments
+         * 2. Accurate parameter definitions matching path parameters
+         * 3. Appropriate request/response body type references
+         * 4. Consistent patterns for CRUD operations
+         *
+         * For list retrievals (typically PATCH), include pagination, search, and
+         * sorting. For detail retrieval (GET), return a single resource. For
+         * creation (POST), use .ICreate request body. For modification (PUT), use
+         * .IUpdate request body.
+         */
+        operations: AutoBeOpenApi.IOperation[] & tags.MinItems<1>;
+    }
+}

package/lib/agent/src/orchestrate/interface/structures/IAutoBeInterfaceAuthorizationsApplication.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAutoBeInterfaceAuthorizationsApplication.js.map

package/lib/agent/src/orchestrate/interface/structures/IAutoBeInterfaceAuthorizationsApplication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAutoBeInterfaceAuthorizationsApplication.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/interface/structures/IAutoBeInterfaceAuthorizationsApplication.ts"],"names":[],"mappings":""}

package/lib/agent/src/orchestrate/interface/structures/IAutoBeInterfaceComplementApplication.d.ts

@@ -0,0 +1,93 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+export interface IAutoBeInterfaceComplementApplication {
+    /**
+     * Complements missing schema types
+     *
+     * This method fills in schema definitions that are referenced via $ref but
+     * not yet defined in the `components.schemas` section. For example, if an API
+     * operation references `{ "$ref": "#/components/schemas/UserProfile" }` but
+     * `UserProfile` type is not defined in `components.schemas`, this method will
+     * add the missing schema definition.
+     *
+     * This function is designed to be called via AI function calling mechanism to
+     * ensure the OpenAPI document is complete and all referenced schemas are
+     * properly defined.
+     */
+    complementComponents(props: IAutoBeInterfaceComplementApplication.IProps): void;
+}
+export declare namespace IAutoBeInterfaceComplementApplication {
+    interface IProps {
+        /**
+         * TypeScript draft code for complement schema definitions.
+         *
+         * This property contains TypeScript interface definitions for missing schema
+         * types that were referenced but not defined in the initial schema generation.
+         * Similar to the main schema draft, this serves as a preliminary TypeScript
+         * representation before converting to JSON Schema format.
+         *
+         * The draft helps ensure that complementary schemas maintain consistency with
+         * the existing type system and follow the same conventions as the primary schemas.
+         *
+         * This draft typically includes:
+         * - Missing entity interfaces referenced via $ref
+         * - Nested object types used within other schemas
+         * - Shared utility types or enumerations
+         * - Any transitively referenced types
+         *
+         * The final schemas in the `schemas` property should be validated against and
+         * derived from this TypeScript draft to ensure type safety and consistency
+         * across the entire API specification.
+         *
+         * Example complement draft:
+         * ```typescript
+         * interface IUserProfile {
+         *   id: string;
+         *   userId: string;
+         *   displayName: string;
+         *   avatarUrl?: string;
+         * }
+         *
+         * interface IAddress {
+         *   street: string;
+         *   city: string;
+         *   postalCode: string;
+         * }
+         * ```
+         */
+        draft: string;
+        /**
+         * A collection of missing schema definitions that need to be added to the
+         * OpenAPI document's `components.schemas` section.
+         *
+         * This object contains schema definitions for types that are referenced but
+         * not yet defined:
+         *
+         * - Key: Schema name (`string`): The name of the schema type that will be
+         *   referenced in $ref statements
+         * - Value: `AutoBeOpenApi.IJsonSchema` - The complete JSON Schema definition
+         *   for that type
+         *
+         * Example structure:
+         *
+         * ```typescript
+         * {
+         *   "UserProfile": {
+         *     "type": "object",
+         *     "properties": {
+         *       "id": { "type": "string" },
+         *       "name": { "type": "string" },
+         *       "email": { "type": "string", "format": "email" }
+         *     },
+         *     "required": ["id", "name", "email"]
+         *   }
+         * }
+         * ```
+         *
+         * Each schema definition follows the JSON Schema specification and will be
+         * directly inserted into the OpenAPI document's components.schemas section,
+         * making them available for $ref references throughout the API
+         * specification.
+         */
+        schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    }
+}

package/lib/agent/src/orchestrate/interface/structures/IAutoBeInterfaceComplementApplication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAutoBeInterfaceComplementApplication.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/interface/structures/IAutoBeInterfaceComplementApplication.ts"],"names":[],"mappings":""}