@autobe/agent 0.16.1 → 0.18.0

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

@@ -0,0 +1,467 @@
+"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 typia_1 = __importDefault(require("typia"));
+const transformInterfaceSchemasReviewHistories_1 = require("./histories/transformInterfaceSchemasReviewHistories");
+function orchestrateInterfaceSchemasReview(ctx, operations, schemas, progress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        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)
+            throw new Error("Failed to extract review information.");
+        ctx.dispatch({
+            type: "interfaceSchemasReview",
+            schemas: schemas,
+            review: pointer.value.review,
+            plan: pointer.value.plan,
+            content: pointer.value.content,
+            tokenUsage,
+            step: (_b = (_a = ctx.state().analyze) === null || _a === void 0 ? void 0 : _a.step) !== null && _b !== void 0 ? _b : 0,
+            total: progress.total,
+            completed: ++progress.completed,
+            created_at: new Date().toISOString(),
+        });
+        return pointer.value.content;
+    });
+}
+function createController(props) {
+    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 = [];
+        if (Object.keys(result.data.content).length === 0) {
+            console.log();
+            console.log();
+            console.log();
+            console.log(JSON.stringify(Object.assign({ schemas: props.schemas }, result.data), null, 2));
+            errors.push({
+                path: `$input.content`,
+                expected: `Content must not be empty. If it's at a level that can't be fixed, please create a schema instead to meet the requirements.`,
+                value: result.data.content,
+            });
+        }
+        if (errors.length > 0) {
+            return {
+                success: false,
+                errors,
+                data: result.data,
+            };
+        }
+        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 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\nIMPORTANT: Only document problems that need fixing. Do NOT include:\n\n- Positive feedback about what's already correct\n- Compliments about well-structured schemas\n- Confirmation that certain aspects meet standards\n\nFocus exclusively on issues organized by severity:\n\n- CRITICAL: Security vulnerabilities (exposed passwords, missing auth\n  boundaries)\n- HIGH: Missing required variants, incorrect type mappings\n- MEDIUM: Missing format specifications, incomplete relationships\n- LOW: 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\nCRITICAL REQUIREMENTS:\n\n- MUST NEVER be an empty object {}\n- MUST contain valid OpenAPI schema definitions\n- MUST include all entities that were in the original input\n- If original schemas have critical issues, MUST contain fixed versions\n- If entity names are wrong, MUST contain renamed correct versions\n- If schemas are missing variants, MUST include the created variants\n\nFORBIDDEN:\n\n- Empty object {} will cause all schemas to be deleted\n- Returning undefined or null\n- Including explanations or excuses in schema descriptions\n- Leaving 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;
+})();
+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> CRITICAL REQUIREMENTS:\n> \n> - MUST NEVER be an empty object {}\n> - MUST contain valid OpenAPI schema definitions\n> - MUST include all entities that were in the original input\n> - If original schemas have critical issues, MUST contain fixed versions\n> - If entity names are wrong, MUST contain renamed correct versions\n> - If schemas are missing variants, MUST include the created variants\n> \n> FORBIDDEN:\n> \n> - Empty object {} will cause all schemas to be deleted\n> - Returning undefined or null\n> - Including explanations or excuses in schema descriptions\n> - Leaving 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\nIMPORTANT: Only document problems that need fixing. Do NOT include:\n\n- Positive feedback about what's already correct\n- Compliments about well-structured schemas\n- Confirmation that certain aspects meet standards\n\nFocus exclusively on issues organized by severity:\n\n- CRITICAL: Security vulnerabilities (exposed passwords, missing auth\n  boundaries)\n- HIGH: Missing required variants, incorrect type mappings\n- MEDIUM: Missing format specifications, incomplete relationships\n- LOW: 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,
+    llama: claude,
+    deepseek: claude,
+    "3.1": claude,
+};
+//# 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":"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"}

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,55 @@
+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 {
+        /**
+         * 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":""}

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

@@ -0,0 +1,24 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { tags } from "typia";
+export interface IAutoBeInterfaceEndpointApplication {
+    /**
+     * Create Restful API endpoints.
+     *
+     * Create Restful API endpoints referencing the given documents; requirement
+     * analysis documents, and Prisma schema files with ERD descriptions. The API
+     * endpoints must cover every requirements and every entities in the ERD.
+     *
+     * Also, each combination of {@link AutoBeOpenApi.IEndpoint.path} and
+     * {@link AutoBeOpenApi.IEndpoint.method} must be unique to avoid duplicates.
+     * Please don't make any duplicates.
+     *
+     * @param props Properties containing the endpoints
+     */
+    makeEndpoints(props: IAutoBeInterfaceEndpointApplication.IProps): void;
+}
+export declare namespace IAutoBeInterfaceEndpointApplication {
+    interface IProps {
+        /** The endpoints to generate. */
+        endpoints: AutoBeOpenApi.IEndpoint[] & tags.MinItems<1>;
+    }
+}

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

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