@autobe/agent 0.17.1 → 0.19.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrateInterfaceOperationsReview.js","sourceRoot":"","sources":["../../../../../src/orchestrate/interface/orchestrateInterfaceOperationsReview.ts"],"names":[],"mappings":"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;;;;;KAGJ;IACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGH;CACJ,CAAC"}

package/lib/agent/src/orchestrate/interface/orchestrateInterfaceSchemas.d.ts

@@ -0,0 +1,4 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare function orchestrateInterfaceSchemas<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operations: AutoBeOpenApi.IOperation[], capacity?: number): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>>;

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

@@ -0,0 +1,561 @@
+"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.orchestrateInterfaceSchemas = orchestrateInterfaceSchemas;
+const __typia_transform__accessExpressionAsString = __importStar(require("typia/lib/internal/_accessExpressionAsString.js"));
+const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
+const __typia_transform__llmApplicationFinalize = __importStar(require("typia/lib/internal/_llmApplicationFinalize.js"));
+const OpenApiV3_1Emender_1 = require("@samchon/openapi/lib/converters/OpenApiV3_1Emender");
+const typia_1 = __importDefault(require("typia"));
+const assertSchemaModel_1 = require("../../context/assertSchemaModel");
+const divideArray_1 = require("../../utils/divideArray");
+const transformInterfaceSchemaHistories_1 = require("./histories/transformInterfaceSchemaHistories");
+const orchestrateInterfaceSchemasReview_1 = require("./orchestrateInterfaceSchemasReview");
+const validateAuthorizationSchema_1 = require("./utils/validateAuthorizationSchema");
+function orchestrateInterfaceSchemas(ctx_1, operations_1) {
+    return __awaiter(this, arguments, void 0, function* (ctx, operations, capacity = 8) {
+        var _a, _b;
+        const typeNames = new Set();
+        for (const op of operations) {
+            if (op.requestBody !== null)
+                typeNames.add(op.requestBody.typeName);
+            if (op.responseBody !== null)
+                typeNames.add(op.responseBody.typeName);
+        }
+        const matrix = (0, divideArray_1.divideArray)({
+            array: Array.from(typeNames),
+            capacity,
+        });
+        const progress = {
+            total: typeNames.size,
+            completed: 0,
+        };
+        const reviewProgress = {
+            total: matrix.length,
+            completed: 0,
+        };
+        const roles = (_b = (_a = ctx.state().analyze) === null || _a === void 0 ? void 0 : _a.roles.map((role) => role.name)) !== null && _b !== void 0 ? _b : [];
+        const x = roles.length > 0
+            ? {
+                IAuthorizationToken: authTokenSchema,
+            }
+            : {};
+        for (const y of yield Promise.all(matrix.map((it) => __awaiter(this, void 0, void 0, function* () {
+            const row = yield divideAndConquer(ctx, operations, it, 3, progress);
+            const newbie = yield (0, orchestrateInterfaceSchemasReview_1.orchestrateInterfaceSchemasReview)(ctx, operations, row, reviewProgress);
+            return Object.assign(Object.assign({}, row), newbie);
+        })))) {
+            Object.assign(x, y);
+        }
+        if (x.IAuthorizationToken)
+            x.IAuthorizationToken = authTokenSchema;
+        return x;
+    });
+}
+function divideAndConquer(ctx, operations, typeNames, retry, progress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const remained = new Set(typeNames);
+        const schemas = {};
+        for (let i = 0; i < retry; ++i) {
+            if (remained.size === 0)
+                break;
+            const newbie = yield process(ctx, operations, schemas, remained, progress);
+            for (const key of Object.keys(newbie)) {
+                schemas[key] = newbie[key];
+                remained.delete(key);
+            }
+        }
+        return schemas;
+    });
+}
+function process(ctx, operations, oldbie, remained, progress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const already = Object.keys(oldbie);
+        const pointer = {
+            value: null,
+        };
+        const { tokenUsage } = yield ctx.conversate({
+            source: "interfaceSchemas",
+            histories: (0, transformInterfaceSchemaHistories_1.transformInterfaceSchemaHistories)(ctx.state(), operations),
+            controller: createController({
+                model: ctx.model,
+                build: (next) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    (_a = pointer.value) !== null && _a !== void 0 ? _a : (pointer.value = {});
+                    Object.assign(pointer.value, next);
+                }),
+                pointer,
+            }),
+            enforceFunctionCall: true,
+            message: [
+                "Make type components please.",
+                "",
+                "Here is the list of request/response bodies' type names from",
+                "OpenAPI operations. Make type components of them. If more object",
+                "types are required during making the components, please make them",
+                "too.",
+                "",
+                ...Array.from(remained).map((k) => `- \`${k}\``),
+                ...(already.length !== 0
+                    ? [
+                        "",
+                        "> By the way, here is the list of components schemas what you've",
+                        "> already made. So, you don't need to make them again.",
+                        ">",
+                        ...already.map((k) => `> - \`${k}\``),
+                    ]
+                    : []),
+            ].join("\n"),
+        });
+        if (pointer.value === null)
+            throw new Error("Failed to create components.");
+        const schemas = (_a = OpenApiV3_1Emender_1.OpenApiV3_1Emender.convertComponents({
+            schemas: pointer.value,
+        }).schemas) !== null && _a !== void 0 ? _a : {};
+        ctx.dispatch({
+            type: "interfaceSchemas",
+            schemas,
+            tokenUsage,
+            completed: (progress.completed += Object.keys(schemas).length),
+            total: (progress.total += Object.keys(schemas).filter((k) => remained.has(k) === false).length),
+            step: (_c = (_b = ctx.state().prisma) === null || _b === void 0 ? void 0 : _b.step) !== null && _c !== void 0 ? _c : 0,
+            created_at: new Date().toISOString(),
+        });
+        return schemas;
+    });
+}
+function createController(props) {
+    (0, assertSchemaModel_1.assertSchemaModel)(props.model);
+    const validate = (next) => {
+        const result = (() => { const _io0 = input => "string" === typeof input.draft && ("object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) && _io1(input.schemas)); const _io1 = input => Object.keys(input).every(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "object" === typeof value && null !== value && _io2(value);
+        }); const _io2 = input => "string" === typeof input.description; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.draft || _report(_exceptionable, {
+                path: _path + ".draft",
+                expected: "string",
+                value: input.draft
+            }), ("object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) || _report(_exceptionable, {
+                path: _path + ".schemas",
+                expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                value: input.schemas
+            })) && _vo1(input.schemas, _path + ".schemas", true && _exceptionable) || _report(_exceptionable, {
+                path: _path + ".schemas",
+                expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                value: input.schemas
+            })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return ("object" === typeof value && null !== value || _report(_exceptionable, {
+                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                    expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
+                    value: 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: "IAutoBeInterfaceSchemaApplication.IProps",
+                    value: input
+                })) && _vo0(input, _path + "", true) || _report(true, {
+                    path: _path + "",
+                    expected: "IAutoBeInterfaceSchemaApplication.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;
+        // Check all IAuthorized types
+        const errors = [];
+        (0, validateAuthorizationSchema_1.validateAuthorizationSchema)({
+            errors,
+            schemas: result.data.schemas,
+            path: "$input.schemas",
+        });
+        if (errors.length !== 0)
+            return {
+                success: false,
+                errors,
+                data: next,
+            };
+        return result;
+    };
+    const application = collection[props.model === "chatgpt" ? "chatgpt" : "claude"](validate);
+    return {
+        protocol: "class",
+        name: "interface",
+        application,
+        execute: {
+            makeComponents: (next) => __awaiter(this, void 0, void 0, function* () {
+                yield props.build(next.schemas);
+            }),
+        },
+    };
+}
+const collection = {
+    chatgpt: (validate) => (() => {
+        const application = {
+            model: "chatgpt",
+            options: {
+                reference: true,
+                strict: false,
+                separate: null
+            },
+            functions: [
+                {
+                    name: "makeComponents",
+                    parameters: {
+                        description: " Properties containing components to generate.\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceSchemaApplication.IProps}\n\n### Description of {@link schemas} property:\n\n> Complete set of schema components for the OpenAPI specification.\n> \n> This property contains comprehensive type definitions for all entities in\n> the system. It is the central repository of all named schema types that\n> will be used throughout the API specification.\n> \n> DO: Define all object types as named types in the components.schemas\n> section. DO NOT: Use inline anonymous object definitions.\n> \n> This components object includes:\n> \n> - Main entity types (IEntityName)\n> - Operation-specific variants (.ICreate, .IUpdate, .ISummary, etc.)\n> - Container types (IPage<T> for pagination)\n> - Enumeration types\n> \n> DO: Include detailed descriptions that reference the original Prisma\n> schema comments and thoroughly document each property. DO: Use a $ref to\n> a named type in the components.schemas section for every property that\n> references an object.\n> \n> This applies to all objects in request bodies, response bodies, and\n> properties that are objects or arrays of objects.\n> \n> Example structure:\n> \n> ```typescript\n> {\n>   schemas: {\n>     IUser: {\n>       type: \"object\",\n>       properties: {\n>         id: { type: \"string\", format: \"uuid\" },\n>         email: { type: \"string\", format: \"email\" },\n>         profile: { \"$ref\": \"#/components/schemas/IUserProfile\" }\n>       },\n>       required: [\"id\", \"email\"],\n>       description: \"User entity representing system account holders...\"\n>     },\n>     \"IUser.ICreate\": { ... },\n>     // Additional schemas\n>   }\n> }\n> ```",
+                        type: "object",
+                        properties: {
+                            draft: {
+                                description: "TypeScript draft code for schema definitions.\n\nThis property contains TypeScript interface definitions that serve as a\npreliminary draft before generating the final JSON schema components.\nThe draft allows for initial design and validation of the schema structure\nusing TypeScript's type system before converting to OpenAPI/JSON Schema format.\n\nThe draft typically includes:\n- Entity interfaces matching the Prisma models\n- Operation-specific variants (ICreate, IUpdate, etc.)\n- Utility types and enumerations\n- Type relationships and constraints\n\nThis TypeScript draft serves as the foundation for the subsequent schema\ngeneration, ensuring type safety and consistency. The final schemas in the\n`schemas` property should be derived from and validated against this draft.\n\nExample draft structure:\n```typescript\ninterface IUser {\n  id: string;\n  email: string;\n  profile: IUserProfile;\n}\n\nnamespace IUser {\n  interface ICreate extends Omit<IUser, \"id\"> {}\n  interface IUpdate extends Partial<ICreate> {}\n}\n```",
+                                type: "string"
+                            },
+                            schemas: {
+                                $ref: "#/$defs/RecordstringAutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema"
+                            }
+                        },
+                        required: [
+                            "draft",
+                            "schemas"
+                        ],
+                        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: "Generate OpenAPI components containing named schema types.\n\nThis method receives a complete set of schema components and integrates\nthem into the final OpenAPI specification. It processes all entity schemas,\ntheir variants, and related type definitions to ensure a comprehensive and\nconsistent API design.\n\nThe provided components should include schemas for all entities identified\nin the previous phases of API path/method definition and operation\ncreation. This ensures that the final OpenAPI document has complete type\ncoverage for all operations.\n\nDO: Follow established naming conventions (IEntityName,\nIEntityName.ICreate, etc.) DO: Document thoroughly with descriptions that\nreference the original Prisma schema comments.",
+                    validate: (() => { const _io0 = input => "string" === typeof input.draft && ("object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) && _io1(input.schemas)); const _io1 = input => Object.keys(input).every(key => {
+                        const value = input[key];
+                        if (undefined === value)
+                            return true;
+                        return "object" === typeof value && null !== value && _io2(value);
+                    }); const _io2 = input => "string" === typeof input.description; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.draft || _report(_exceptionable, {
+                            path: _path + ".draft",
+                            expected: "string",
+                            value: input.draft
+                        }), ("object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) || _report(_exceptionable, {
+                            path: _path + ".schemas",
+                            expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                            value: input.schemas
+                        })) && _vo1(input.schemas, _path + ".schemas", true && _exceptionable) || _report(_exceptionable, {
+                            path: _path + ".schemas",
+                            expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                            value: input.schemas
+                        })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+                            const value = input[key];
+                            if (undefined === value)
+                                return true;
+                            return ("object" === typeof value && null !== value || _report(_exceptionable, {
+                                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                                expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
+                                value: 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: "IAutoBeInterfaceSchemaApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeInterfaceSchemaApplication.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: {
+                makeComponents: validate,
+            },
+        }), { equals: false }));
+        return application;
+    })(),
+    claude: (validate) => (() => {
+        const application = {
+            model: "claude",
+            options: {
+                reference: true,
+                separate: null
+            },
+            functions: [
+                {
+                    name: "makeComponents",
+                    parameters: {
+                        description: " Properties containing components to generate.\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceSchemaApplication.IProps}",
+                        type: "object",
+                        properties: {
+                            draft: {
+                                description: "TypeScript draft code for schema definitions.\n\nThis property contains TypeScript interface definitions that serve as a\npreliminary draft before generating the final JSON schema components.\nThe draft allows for initial design and validation of the schema structure\nusing TypeScript's type system before converting to OpenAPI/JSON Schema format.\n\nThe draft typically includes:\n- Entity interfaces matching the Prisma models\n- Operation-specific variants (ICreate, IUpdate, etc.)\n- Utility types and enumerations\n- Type relationships and constraints\n\nThis TypeScript draft serves as the foundation for the subsequent schema\ngeneration, ensuring type safety and consistency. The final schemas in the\n`schemas` property should be derived from and validated against this draft.\n\nExample draft structure:\n```typescript\ninterface IUser {\n  id: string;\n  email: string;\n  profile: IUserProfile;\n}\n\nnamespace IUser {\n  interface ICreate extends Omit<IUser, \"id\"> {}\n  interface IUpdate extends Partial<ICreate> {}\n}\n```",
+                                type: "string"
+                            },
+                            schemas: {
+                                description: "Complete set of schema components for the OpenAPI specification.\n\nThis property contains comprehensive type definitions for all entities in\nthe system. It is the central repository of all named schema types that\nwill be used throughout the API specification.\n\nDO: Define all object types as named types in the components.schemas\nsection. DO NOT: Use inline anonymous object definitions.\n\nThis components object includes:\n\n- Main entity types (IEntityName)\n- Operation-specific variants (.ICreate, .IUpdate, .ISummary, etc.)\n- Container types (IPage<T> for pagination)\n- Enumeration types\n\nDO: Include detailed descriptions that reference the original Prisma\nschema comments and thoroughly document each property. DO: Use a $ref to\na named type in the components.schemas section for every property that\nreferences an object.\n\nThis applies to all objects in request bodies, response bodies, and\nproperties that are objects or arrays of objects.\n\nExample structure:\n\n```typescript\n{\n  schemas: {\n    IUser: {\n      type: \"object\",\n      properties: {\n        id: { type: \"string\", format: \"uuid\" },\n        email: { type: \"string\", format: \"email\" },\n        profile: { \"$ref\": \"#/components/schemas/IUserProfile\" }\n      },\n      required: [\"id\", \"email\"],\n      description: \"User entity representing system account holders...\"\n    },\n    \"IUser.ICreate\": { ... },\n    // Additional schemas\n  }\n}\n```",
+                                $ref: "#/$defs/RecordstringAutoBeOpenApi.IJsonSchemaDescriptiveAutoBeOpenApi.IJsonSchema"
+                            }
+                        },
+                        required: [
+                            "draft",
+                            "schemas"
+                        ],
+                        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: "Generate OpenAPI components containing named schema types.\n\nThis method receives a complete set of schema components and integrates\nthem into the final OpenAPI specification. It processes all entity schemas,\ntheir variants, and related type definitions to ensure a comprehensive and\nconsistent API design.\n\nThe provided components should include schemas for all entities identified\nin the previous phases of API path/method definition and operation\ncreation. This ensures that the final OpenAPI document has complete type\ncoverage for all operations.\n\nDO: Follow established naming conventions (IEntityName,\nIEntityName.ICreate, etc.) DO: Document thoroughly with descriptions that\nreference the original Prisma schema comments.",
+                    validate: (() => { const _io0 = input => "string" === typeof input.draft && ("object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) && _io1(input.schemas)); const _io1 = input => Object.keys(input).every(key => {
+                        const value = input[key];
+                        if (undefined === value)
+                            return true;
+                        return "object" === typeof value && null !== value && _io2(value);
+                    }); const _io2 = input => "string" === typeof input.description; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.draft || _report(_exceptionable, {
+                            path: _path + ".draft",
+                            expected: "string",
+                            value: input.draft
+                        }), ("object" === typeof input.schemas && null !== input.schemas && false === Array.isArray(input.schemas) || _report(_exceptionable, {
+                            path: _path + ".schemas",
+                            expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                            value: input.schemas
+                        })) && _vo1(input.schemas, _path + ".schemas", true && _exceptionable) || _report(_exceptionable, {
+                            path: _path + ".schemas",
+                            expected: "Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>",
+                            value: input.schemas
+                        })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+                            const value = input[key];
+                            if (undefined === value)
+                                return true;
+                            return ("object" === typeof value && null !== value || _report(_exceptionable, {
+                                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                                expected: "AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>",
+                                value: 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: "IAutoBeInterfaceSchemaApplication.IProps",
+                                value: input
+                            })) && _vo0(input, _path + "", true) || _report(true, {
+                                path: _path + "",
+                                expected: "IAutoBeInterfaceSchemaApplication.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: {
+                makeComponents: validate,
+            },
+        }), { equals: false }));
+        return application;
+    })(),
+};
+const authTokenSchema = {
+    version: "3.1",
+    components: {
+        schemas: {
+            IAuthorizationToken: {
+                type: "object",
+                properties: {
+                    access: {
+                        type: "string",
+                        description: "JWT access token for authenticated requests.\n\nThis token should be included in the Authorization header for subsequent\nauthenticated API requests as `Bearer {token}`."
+                    },
+                    refresh: {
+                        type: "string",
+                        description: "Refresh token for obtaining new access tokens.\n\nThis token can be used to request new access tokens when the current access\ntoken expires, extending the user's session."
+                    },
+                    expired_at: {
+                        type: "string",
+                        format: "date-time",
+                        description: "Access token expiration timestamp.\n\nISO 8601 date-time string indicating when the access token will expire and\ncan no longer be used for authentication."
+                    },
+                    refreshable_until: {
+                        type: "string",
+                        format: "date-time",
+                        description: "Refresh token expiration timestamp.\n\nISO 8601 date-time string indicating the latest time until which the\nrefresh token can be used to obtain new access tokens."
+                    }
+                },
+                required: [
+                    "access",
+                    "refresh",
+                    "expired_at",
+                    "refreshable_until"
+                ],
+                description: "Authorization token response structure.\n\nThis interface defines the structure of the authorization token response\nreturned after successful user authentication. It contains both access and\nrefresh tokens along with their expiration information.\n\nThis token structure is automatically included in API schemas when the system\ndetects authorization roles in the requirements analysis phase. It provides a\nstandard format for JWT-based authentication across the generated backend\napplications."
+            }
+        }
+    },
+    schema: {
+        $ref: "#/components/schemas/IAuthorizationToken"
+    }
+}.components.schemas
+    .IAuthorizationToken;
+//# sourceMappingURL=orchestrateInterfaceSchemas.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrateInterfaceSchemas.js","sourceRoot":"","sources":["../../../../../src/orchestrate/interface/orchestrateInterfaceSchemas.ts"],"names":[],"mappings":"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"}

package/lib/agent/src/orchestrate/interface/orchestrateInterfaceSchemasReview.d.ts

@@ -0,0 +1,7 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare function orchestrateInterfaceSchemasReview<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operations: AutoBeOpenApi.IOperation[], schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>, progress: {
+    total: number;
+    completed: number;
+}): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>>;