@autobe/agent 0.18.0 → 0.20.0

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

@@ -49,43 +49,63 @@ 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 uuid_1 = require("uuid");
+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;
-        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;
+        var _a, _b, _c;
+        try {
+            const pointer = {
+                value: null,
+            };
+            const { tokenUsage } = yield ctx.conversate({
+                source: "interfaceSchemasReview",
+                controller: createController({
+                    model: ctx.model,
+                    pointer,
+                    operations,
+                    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",
+                id: (0, uuid_1.v7)(),
+                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];
@@ -156,24 +176,192 @@ function createController(props) {
         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,
+        (0, validateAuthorizationSchema_1.validateAuthorizationSchema)({
+            errors,
+            schemas: result.data.content,
+            path: "$input.content",
+        });
+        Object.entries(result.data.content).forEach(([tagName, jsonDescriptive]) => {
+            var _a;
+            const index = props.operations.find((op) => {
+                var _a;
+                return ((_a = op.responseBody) === null || _a === void 0 ? void 0 : _a.typeName) === tagName &&
+                    op.method === "patch" &&
+                    op.name === "index";
             });
-        }
-        if (errors.length > 0) {
+            // The index API should return the `IPage<T>` type.
+            if (index) {
+                // First check if the schema has the correct object structure
+                if (!("type" in jsonDescriptive) ||
+                    jsonDescriptive.type !== "object") {
+                    errors.push({
+                        path: `$input.content.${tagName}`,
+                        expected: `{ type: "object", properties: { ... } }`,
+                        value: jsonDescriptive,
+                        description: `IPage schema must have type: "object". Found: ${JSON.stringify(jsonDescriptive)}`,
+                    });
+                }
+                else if (!("properties" in jsonDescriptive)) {
+                    errors.push({
+                        path: `$input.content.${tagName}`,
+                        expected: `Schema with "properties" field`,
+                        value: jsonDescriptive,
+                        description: `IPage schema must have a "properties" field containing "pagination" and "data" properties.`,
+                    });
+                }
+                else if ((() => { const _io0 = input => "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io1(input.properties) && (null !== input.additionalProperties && (undefined === input.additionalProperties || false === input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && _iu1(input.additionalProperties))) && (Array.isArray(input.required) && input.required.every(elem => "string" === typeof elem)) && "object" === input.type; 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 _io3 = input => (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -9223372036854776000 <= input.minimum && input.minimum <= 9223372036854776000)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -9223372036854776000 <= input.maximum && input.maximum <= 9223372036854776000)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 18446744073709552000 && 0 < input.multipleOf)) && "integer" === input.type; const _io4 = input => (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && "number" === input.type; const _io5 = input => (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type; const _io6 = input => "string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]; const _io7 = input => "boolean" === input.type; const _io8 = input => "object" === typeof input.items && null !== input.items && _iu1(input.items) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 18446744073709552000)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 18446744073709552000)) && "array" === input.type; const _io9 = input => "string" === typeof input.$ref; const _io10 = input => Array.isArray(input.oneOf) && input.oneOf.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io12(input.discriminator)); const _io11 = input => "null" === input.type; const _io12 = input => "string" === typeof input.propertyName && (undefined === input.mapping || "object" === typeof input.mapping && null !== input.mapping && false === Array.isArray(input.mapping) && _io13(input.mapping)); const _io13 = input => Object.keys(input).every(key => {
+                    const value = input[key];
+                    if (undefined === value)
+                        return true;
+                    return "string" === typeof value;
+                }); const _iu0 = input => (() => {
+                    if ("number" === input.type)
+                        return _io4(input);
+                    else if ("integer" === input.type)
+                        return _io3(input);
+                    else if ("string" === input.type)
+                        return _io5(input);
+                    else if (undefined !== input["const"])
+                        return _io6(input);
+                    else if ("null" === input.type)
+                        return _io11(input);
+                    else if ("boolean" === input.type)
+                        return _io7(input);
+                    else if ("array" === input.type)
+                        return _io8(input);
+                    else if ("object" === input.type)
+                        return _io0(input);
+                    else if (undefined !== input.$ref)
+                        return _io9(input);
+                    else
+                        return false;
+                })(); const _iu1 = input => (() => {
+                    if ("number" === input.type)
+                        return _io4(input);
+                    else if ("integer" === input.type)
+                        return _io3(input);
+                    else if ("string" === input.type)
+                        return _io5(input);
+                    else if (undefined !== input["const"])
+                        return _io6(input);
+                    else if ("null" === input.type)
+                        return _io11(input);
+                    else if ("boolean" === input.type)
+                        return _io7(input);
+                    else if ("array" === input.type)
+                        return _io8(input);
+                    else if ("object" === input.type)
+                        return _io0(input);
+                    else if (undefined !== input.$ref)
+                        return _io9(input);
+                    else if (undefined !== input.oneOf)
+                        return _io10(input);
+                    else
+                        return false;
+                })(); return input => "object" === typeof input && null !== input && _io0(input); })()(jsonDescriptive)) {
+                    (_a = jsonDescriptive.properties) !== null && _a !== void 0 ? _a : (jsonDescriptive.properties = {});
+                    // Check pagination property
+                    const pagination = jsonDescriptive.properties["pagination"];
+                    if (!pagination || !("$ref" in pagination)) {
+                        errors.push({
+                            path: `$input.content.${tagName}.properties.pagination`,
+                            expected: `{ $ref: "#/components/schemas/IPage.IPagination" }`,
+                            value: pagination,
+                            description: `IPage must have a "pagination" property with $ref to IPage.IPagination.`,
+                        });
+                    }
+                    // Check data property
+                    const data = jsonDescriptive.properties["data"];
+                    if (!(() => { const _io0 = input => "object" === typeof input.items && null !== input.items && _iu1(input.items) && (undefined === input.uniqueItems || "boolean" === typeof input.uniqueItems) && (undefined === input.minItems || "number" === typeof input.minItems && (Math.floor(input.minItems) === input.minItems && 0 <= input.minItems && input.minItems <= 18446744073709552000)) && (undefined === input.maxItems || "number" === typeof input.maxItems && (Math.floor(input.maxItems) === input.maxItems && 0 <= input.maxItems && input.maxItems <= 18446744073709552000)) && "array" === input.type; const _io1 = input => (undefined === input.minimum || "number" === typeof input.minimum && (Math.floor(input.minimum) === input.minimum && -9223372036854776000 <= input.minimum && input.minimum <= 9223372036854776000)) && (undefined === input.maximum || "number" === typeof input.maximum && (Math.floor(input.maximum) === input.maximum && -9223372036854776000 <= input.maximum && input.maximum <= 9223372036854776000)) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && (Math.floor(input.multipleOf) === input.multipleOf && 0 <= input.multipleOf && input.multipleOf <= 18446744073709552000 && 0 < input.multipleOf)) && "integer" === input.type; const _io2 = input => (undefined === input.minimum || "number" === typeof input.minimum) && (undefined === input.maximum || "number" === typeof input.maximum) && (undefined === input.exclusiveMinimum || "number" === typeof input.exclusiveMinimum) && (undefined === input.exclusiveMaximum || "number" === typeof input.exclusiveMaximum) && (undefined === input.multipleOf || "number" === typeof input.multipleOf && 0 < input.multipleOf) && "number" === input.type; const _io3 = input => (undefined === input.format || "string" === typeof input.format) && (undefined === input.pattern || "string" === typeof input.pattern) && (undefined === input.contentMediaType || "string" === typeof input.contentMediaType) && (undefined === input.minLength || "number" === typeof input.minLength && (Math.floor(input.minLength) === input.minLength && 0 <= input.minLength && input.minLength <= 18446744073709552000)) && (undefined === input.maxLength || "number" === typeof input.maxLength && (Math.floor(input.maxLength) === input.maxLength && 0 <= input.maxLength && input.maxLength <= 18446744073709552000)) && "string" === input.type; const _io4 = input => "string" === typeof input["const"] || "number" === typeof input["const"] || "boolean" === typeof input["const"]; const _io5 = input => "boolean" === input.type; const _io6 = input => "object" === typeof input.properties && null !== input.properties && false === Array.isArray(input.properties) && _io7(input.properties) && (null !== input.additionalProperties && (undefined === input.additionalProperties || false === input.additionalProperties || "object" === typeof input.additionalProperties && null !== input.additionalProperties && _iu1(input.additionalProperties))) && (Array.isArray(input.required) && input.required.every(elem => "string" === typeof elem)) && "object" === input.type; const _io7 = input => Object.keys(input).every(key => {
+                        const value = input[key];
+                        if (undefined === value)
+                            return true;
+                        return "object" === typeof value && null !== value && _io8(value);
+                    }); const _io8 = input => "string" === typeof input.description; const _io9 = input => "string" === typeof input.$ref; const _io10 = input => Array.isArray(input.oneOf) && input.oneOf.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)) && (undefined === input.discriminator || "object" === typeof input.discriminator && null !== input.discriminator && _io12(input.discriminator)); const _io11 = input => "null" === input.type; const _io12 = input => "string" === typeof input.propertyName && (undefined === input.mapping || "object" === typeof input.mapping && null !== input.mapping && false === Array.isArray(input.mapping) && _io13(input.mapping)); const _io13 = input => Object.keys(input).every(key => {
+                        const value = input[key];
+                        if (undefined === value)
+                            return true;
+                        return "string" === typeof value;
+                    }); const _iu0 = input => (() => {
+                        if ("number" === input.type)
+                            return _io2(input);
+                        else if ("integer" === input.type)
+                            return _io1(input);
+                        else if ("string" === input.type)
+                            return _io3(input);
+                        else if (undefined !== input["const"])
+                            return _io4(input);
+                        else if ("null" === input.type)
+                            return _io11(input);
+                        else if ("boolean" === input.type)
+                            return _io5(input);
+                        else if ("array" === input.type)
+                            return _io0(input);
+                        else if ("object" === input.type)
+                            return _io6(input);
+                        else if (undefined !== input.$ref)
+                            return _io9(input);
+                        else
+                            return false;
+                    })(); const _iu1 = input => (() => {
+                        if ("number" === input.type)
+                            return _io2(input);
+                        else if ("integer" === input.type)
+                            return _io1(input);
+                        else if ("string" === input.type)
+                            return _io3(input);
+                        else if (undefined !== input["const"])
+                            return _io4(input);
+                        else if ("null" === input.type)
+                            return _io11(input);
+                        else if ("boolean" === input.type)
+                            return _io5(input);
+                        else if ("array" === input.type)
+                            return _io0(input);
+                        else if ("object" === input.type)
+                            return _io6(input);
+                        else if (undefined !== input.$ref)
+                            return _io9(input);
+                        else if (undefined !== input.oneOf)
+                            return _io10(input);
+                        else
+                            return false;
+                    })(); return input => "object" === typeof input && null !== input && _io0(input); })()(data)) {
+                        errors.push({
+                            path: `$input.content.${tagName}.properties.data`,
+                            expected: `AutoBeOpenApi.IJsonSchema.IArray`,
+                            value: data,
+                            description: `The 'data' property must be an array for the index operation.`,
+                        });
+                    }
+                    else {
+                        // Check if array items have proper type reference (not 'any')
+                        const arraySchema = data;
+                        if (!arraySchema.items ||
+                            !("$ref" in arraySchema.items) ||
+                            arraySchema.items.$ref === "#/components/schemas/any") {
+                            errors.push({
+                                path: `$input.content.${tagName}.properties.data.items`,
+                                expected: `Reference to a specific type (e.g., $ref to ISummary type)`,
+                                value: arraySchema.items,
+                                description: `The 'data' array must have a specific item type, not 'any[]'. Use a proper type reference like '{Entity}.ISummary' for paginated results.`,
+                            });
+                        }
+                    }
+                }
+            }
+        });
+        if (errors.length !== 0)
             return {
                 success: false,
                 errors,
-                data: result.data,
+                data: next,
             };
-        }
         return result;
     };
     const application = collection[props.model === "chatgpt" ? "chatgpt" : "claude"](validate);
@@ -188,159 +376,158 @@ function createController(props) {
         },
     };
 }
-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"
+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"
                             }
                         },
-                        "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: [
+                            "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"
                                 }
                             },
-                            required: [
-                                "description"
-                            ]
+                            "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 => {
+                    },
+                    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 || _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,
+                        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
                         };
-                    }
-                    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) => (() => {
+                    }; })()
+                }
+            ]
+        };
+        __typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, Object.assign(Object.assign({}, {
+            validate: {
+                review: validate,
+            },
+        }), { equals: false }));
+        return application;
+    })(),
+    claude: (validate) => (() => {
         const application = {
-            model: "chatgpt",
+            model: "claude",
             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.",
+                        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.\"",
+                                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: {
@@ -348,6 +535,7 @@ const collection = {
                                 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"
                             }
                         },
@@ -459,9 +647,5 @@ const collection = {
         }), { equals: false }));
         return application;
     })(),
-    claude,
-    llama: claude,
-    deepseek: claude,
-    "3.1": claude,
 };
 //# sourceMappingURL=orchestrateInterfaceSchemasReview.js.map