@autobe/agent 0.22.1 → 0.23.1

package/lib/{agent/src/orchestrate → orchestrate}/test/orchestrateTestScenario.js

@@ -51,6 +51,7 @@ const __typia_transform__llmApplicationFinalize = __importStar(require("typia/li
 const utils_1 = require("@autobe/utils");
 const tstl_1 = require("tstl");
 const typia_1 = __importDefault(require("typia"));
+const NamingConvention_1 = require("typia/lib/utils/NamingConvention");
 const uuid_1 = require("uuid");
 const assertSchemaModel_1 = require("../../context/assertSchemaModel");
 const divideArray_1 = require("../../utils/divideArray");
@@ -58,12 +59,13 @@ const executeCachedBatch_1 = require("../../utils/executeCachedBatch");
 const transformTestScenarioHistories_1 = require("./histories/transformTestScenarioHistories");
 function orchestrateTestScenario(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const operations = (_b = (_a = ctx.state().interface) === null || _a === void 0 ? void 0 : _a.document.operations) !== null && _b !== void 0 ? _b : [];
-        if (operations.length === 0) {
+        var _a;
+        const document = (_a = ctx.state().interface) === null || _a === void 0 ? void 0 : _a.document;
+        if (document === undefined) {
             throw new Error("Cannot write test scenarios because these are no operations.");
         }
-        const dict = new tstl_1.HashMap(operations.map((op) => new tstl_1.Pair({
+        Object.entries(document.components.schemas);
+        const dict = new tstl_1.HashMap(document.operations.map((op) => new tstl_1.Pair({
             path: op.path,
             method: op.method,
         }, op)), utils_1.AutoBeEndpointComparator.hashCode, utils_1.AutoBeEndpointComparator.equals);
@@ -72,14 +74,17 @@ function orchestrateTestScenario(ctx) {
             "",
             " method | path ",
             "--------|------",
-            ...operations.map((op) => `\`${op.method}\` | \`${op.path}\``).join("\n"),
+            ...document.operations
+                .map((op) => `\`${op.method}\` | \`${op.path}\``)
+                .join("\n"),
         ].join("\n");
         const progress = {
-            total: operations.length,
+            total: document.operations.length,
             completed: 0,
         };
         const exclude = [];
-        let include = Array.from(operations);
+        let include = [...document.operations];
+        let trial = 0;
         do {
             const matrix = (0, divideArray_1.divideArray)({
                 array: include,
@@ -89,7 +94,7 @@ function orchestrateTestScenario(ctx) {
                 exclude.push(...(yield divideAndConquer(ctx, {
                     dict,
                     endpointNotFound,
-                    entire: operations,
+                    document,
                     include,
                     exclude: exclude.map((x) => x.endpoint),
                     progress,
@@ -102,7 +107,8 @@ function orchestrateTestScenario(ctx) {
                 }
                 return true;
             });
-        } while (include.length > 0);
+            progress.total = include.length + exclude.length;
+        } while (include.length > 0 && ++trial < ctx.retry);
         return exclude.flatMap((pg) => {
             return pg.scenarios.map((plan) => {
                 return {
@@ -124,7 +130,7 @@ const divideAndConquer = (ctx, props) => __awaiter(void 0, void 0, void 0, funct
     try {
         const { tokenUsage } = yield ctx.conversate({
             source: "testScenarios",
-            histories: (0, transformTestScenarioHistories_1.transformTestScenarioHistories)(ctx.state(), props.entire, props.include, props.exclude),
+            histories: (0, transformTestScenarioHistories_1.transformTestScenarioHistories)(ctx.state(), props.document, props.include, props.exclude),
             controller: createController({
                 model: ctx.model,
                 endpointNotFound: props.endpointNotFound,
@@ -132,6 +138,9 @@ const divideAndConquer = (ctx, props) => __awaiter(void 0, void 0, void 0, funct
                 authorizations,
                 build: (next) => {
                     var _a;
+                    next.scenarioGroups.forEach((sg) => sg.scenarios.forEach((s) => {
+                        s.functionName = NamingConvention_1.NamingConvention.snake(s.functionName);
+                    }));
                     (_a = pointer.value) !== null && _a !== void 0 ? _a : (pointer.value = []);
                     pointer.value.push(...next.scenarioGroups);
                 },
@@ -142,6 +151,7 @@ const divideAndConquer = (ctx, props) => __awaiter(void 0, void 0, void 0, funct
         });
         if (pointer.value.length === 0)
             return [];
+        props.progress.total = Math.max(props.progress.total, (props.progress.completed += pointer.value.length));
         ctx.dispatch({
             type: "testScenarios",
             id: (0, uuid_1.v7)(),
@@ -154,7 +164,7 @@ const divideAndConquer = (ctx, props) => __awaiter(void 0, void 0, void 0, funct
                 dependencies: s.dependencies,
             })))
                 .flat(),
-            completed: (props.progress.completed += pointer.value.length),
+            completed: props.progress.completed,
             total: props.progress.total,
             step: (_d = (_c = ctx.state().interface) === null || _c === void 0 ? void 0 : _c.step) !== null && _d !== void 0 ? _d : 0,
             created_at: new Date().toISOString(),
@@ -162,14 +172,13 @@ const divideAndConquer = (ctx, props) => __awaiter(void 0, void 0, void 0, funct
         return pointer.value;
     }
     catch (_e) {
-        console.log("test scenario, failed to function call", props.include);
         return [];
     }
 });
 function createController(props) {
     (0, assertSchemaModel_1.assertSchemaModel)(props.model);
     const validate = (next) => {
-        const result = (() => { const _io0 = input => Array.isArray(input.scenarioGroups) && input.scenarioGroups.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && (Array.isArray(input.scenarios) && (1 <= input.scenarios.length && input.scenarios.every(elem => "object" === typeof elem && null !== elem && _io3(elem)))); const _io2 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io3 = input => "string" === typeof input.draft && ("string" === typeof input.functionName && RegExp("^[a-z][a-z0-9_]*$").test(input.functionName)) && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))); const _io4 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && "string" === typeof input.purpose; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.scenarioGroups) || _report(_exceptionable, {
+        const result = (() => { const _io0 = input => Array.isArray(input.scenarioGroups) && input.scenarioGroups.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && (Array.isArray(input.scenarios) && (1 <= input.scenarios.length && input.scenarios.every(elem => "object" === typeof elem && null !== elem && _io3(elem)))); const _io2 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io3 = input => "string" === typeof input.draft && "string" === typeof input.functionName && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))); const _io4 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && "string" === typeof input.purpose; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.scenarioGroups) || _report(_exceptionable, {
                 path: _path + ".scenarioGroups",
                 expected: "Array<IAutoBeTestScenarioApplication.IScenarioGroup>",
                 value: input.scenarioGroups
@@ -229,13 +238,9 @@ function createController(props) {
                 path: _path + ".draft",
                 expected: "string",
                 value: input.draft
-            }), "string" === typeof input.functionName && (RegExp("^[a-z][a-z0-9_]*$").test(input.functionName) || _report(_exceptionable, {
-                path: _path + ".functionName",
-                expected: "string & SnakePattern",
-                value: input.functionName
-            })) || _report(_exceptionable, {
+            }), "string" === typeof input.functionName || _report(_exceptionable, {
                 path: _path + ".functionName",
-                expected: "(string & SnakePattern)",
+                expected: "string",
                 value: input.functionName
             }), (Array.isArray(input.dependencies) || _report(_exceptionable, {
                 path: _path + ".dependencies",
@@ -540,7 +545,7 @@ const collection = {
                                         type: "string"
                                     },
                                     functionName: {
-                                        description: "Descriptive function name derived from the user scenario.\n\nThe function name serves as a concise, technical identifier that clearly\nrepresents the specific user scenario being described. It should be\nimmediately understandable and directly correspond to the user situation\nwithout requiring additional context.\n\n## Naming Convention\n\nDO: Use snake_case naming convention.\n\n- Must start with `test_api_` prefix (mandatory requirement)\n- ALWAYS start with business feature, NOT action verbs\n- Business feature comes first, followed by scenario context\n- Embed action verbs within the scenario description, not at the beginning\n\n## Content Structure\n\nFunction names should follow this pattern:\n`test_api_[core_feature]_[specific_scenario]`\n\nWhere:\n\n- `core_feature`: The main business feature or entity being tested\n  (customer, seller, cart, push_message, etc.)\n- `specific_scenario`: The specific operation or scenario context\n  (join_verification_not_found, login_success,\n  moderator_assignment_update, discountable_ticket_duplicated,\n  csv_export, etc.)\n\n## Business Feature-Based Examples\n\n- `test_api_customer_join_verification_not_found` - Customer join\n  verification when verification code not found\n- `test_api_seller_login` - Seller login operation\n- `test_api_cart_discountable_ticket_duplicated` - Cart discountable ticket\n  with duplication scenario\n- `test_api_push_message_csv` - Push message functionality with CSV format\n- `test_api_product_review_update` - Product review update operation\n\n## Clarity Guidelines\n\n- Prioritize clarity over brevity\n- Avoid technical jargon or implementation terms\n- Use terminology that reflects user perspective\n- Ensure the name alone conveys the user's intent\n- Make it understandable to non-technical stakeholders\n- Keep consistent with user scenario description\n\n## Single Endpoint Alignment\n\nFunction names must reflect scenarios that:\n\n- Accomplish user goals through this single endpoint only\n- Don't imply dependency on other API operations\n- Represent complete user interactions\n\n\n@pattern ^[a-z][a-z0-9_]*$",
+                                        description: "Descriptive function name derived from the user scenario.\n\nThe function name serves as a concise, technical identifier that clearly\nrepresents the specific user scenario being described. It should be\nimmediately understandable and directly correspond to the user situation\nwithout requiring additional context.\n\n## Naming Convention\n\nDO: Use snake_case naming convention.\n\n- Must start with `test_api_` prefix (mandatory requirement)\n- ALWAYS start with business feature, NOT action verbs\n- Business feature comes first, followed by scenario context\n- Embed action verbs within the scenario description, not at the beginning\n\n## Content Structure\n\nFunction names should follow this pattern:\n`test_api_[core_feature]_[specific_scenario]`\n\nWhere:\n\n- `core_feature`: The main business feature or entity being tested\n  (customer, seller, cart, push_message, etc.)\n- `specific_scenario`: The specific operation or scenario context\n  (join_verification_not_found, login_success,\n  moderator_assignment_update, discountable_ticket_duplicated,\n  csv_export, etc.)\n\n## Business Feature-Based Examples\n\n- `test_api_customer_join_verification_not_found` - Customer join\n  verification when verification code not found\n- `test_api_seller_login` - Seller login operation\n- `test_api_cart_discountable_ticket_duplicated` - Cart discountable ticket\n  with duplication scenario\n- `test_api_push_message_csv` - Push message functionality with CSV format\n- `test_api_product_review_update` - Product review update operation\n\n## Clarity Guidelines\n\n- Prioritize clarity over brevity\n- Avoid technical jargon or implementation terms\n- Use terminology that reflects user perspective\n- Ensure the name alone conveys the user's intent\n- Make it understandable to non-technical stakeholders\n- Keep consistent with user scenario description\n\n## Single Endpoint Alignment\n\nFunction names must reflect scenarios that:\n\n- Accomplish user goals through this single endpoint only\n- Don't imply dependency on other API operations\n- Represent complete user interactions",
                                         type: "string"
                                     },
                                     dependencies: {
@@ -577,7 +582,7 @@ const collection = {
                         }
                     },
                     description: "Make test scenarios for the given endpoints.",
-                    validate: (() => { const _io0 = input => Array.isArray(input.scenarioGroups) && input.scenarioGroups.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && (Array.isArray(input.scenarios) && (1 <= input.scenarios.length && input.scenarios.every(elem => "object" === typeof elem && null !== elem && _io3(elem)))); const _io2 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io3 = input => "string" === typeof input.draft && ("string" === typeof input.functionName && RegExp("^[a-z][a-z0-9_]*$").test(input.functionName)) && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))); const _io4 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && "string" === typeof input.purpose; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.scenarioGroups) || _report(_exceptionable, {
+                    validate: (() => { const _io0 = input => Array.isArray(input.scenarioGroups) && input.scenarioGroups.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && (Array.isArray(input.scenarios) && (1 <= input.scenarios.length && input.scenarios.every(elem => "object" === typeof elem && null !== elem && _io3(elem)))); const _io2 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io3 = input => "string" === typeof input.draft && "string" === typeof input.functionName && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))); const _io4 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && "string" === typeof input.purpose; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.scenarioGroups) || _report(_exceptionable, {
                             path: _path + ".scenarioGroups",
                             expected: "Array<IAutoBeTestScenarioApplication.IScenarioGroup>",
                             value: input.scenarioGroups
@@ -637,13 +642,9 @@ const collection = {
                             path: _path + ".draft",
                             expected: "string",
                             value: input.draft
-                        }), "string" === typeof input.functionName && (RegExp("^[a-z][a-z0-9_]*$").test(input.functionName) || _report(_exceptionable, {
-                            path: _path + ".functionName",
-                            expected: "string & SnakePattern",
-                            value: input.functionName
-                        })) || _report(_exceptionable, {
+                        }), "string" === typeof input.functionName || _report(_exceptionable, {
                             path: _path + ".functionName",
-                            expected: "(string & SnakePattern)",
+                            expected: "string",
                             value: input.functionName
                         }), (Array.isArray(input.dependencies) || _report(_exceptionable, {
                             path: _path + ".dependencies",
@@ -804,8 +805,7 @@ const collection = {
                                     },
                                     functionName: {
                                         description: "Descriptive function name derived from the user scenario.\n\nThe function name serves as a concise, technical identifier that clearly\nrepresents the specific user scenario being described. It should be\nimmediately understandable and directly correspond to the user situation\nwithout requiring additional context.\n\n## Naming Convention\n\nDO: Use snake_case naming convention.\n\n- Must start with `test_api_` prefix (mandatory requirement)\n- ALWAYS start with business feature, NOT action verbs\n- Business feature comes first, followed by scenario context\n- Embed action verbs within the scenario description, not at the beginning\n\n## Content Structure\n\nFunction names should follow this pattern:\n`test_api_[core_feature]_[specific_scenario]`\n\nWhere:\n\n- `core_feature`: The main business feature or entity being tested\n  (customer, seller, cart, push_message, etc.)\n- `specific_scenario`: The specific operation or scenario context\n  (join_verification_not_found, login_success,\n  moderator_assignment_update, discountable_ticket_duplicated,\n  csv_export, etc.)\n\n## Business Feature-Based Examples\n\n- `test_api_customer_join_verification_not_found` - Customer join\n  verification when verification code not found\n- `test_api_seller_login` - Seller login operation\n- `test_api_cart_discountable_ticket_duplicated` - Cart discountable ticket\n  with duplication scenario\n- `test_api_push_message_csv` - Push message functionality with CSV format\n- `test_api_product_review_update` - Product review update operation\n\n## Clarity Guidelines\n\n- Prioritize clarity over brevity\n- Avoid technical jargon or implementation terms\n- Use terminology that reflects user perspective\n- Ensure the name alone conveys the user's intent\n- Make it understandable to non-technical stakeholders\n- Keep consistent with user scenario description\n\n## Single Endpoint Alignment\n\nFunction names must reflect scenarios that:\n\n- Accomplish user goals through this single endpoint only\n- Don't imply dependency on other API operations\n- Represent complete user interactions",
-                                        type: "string",
-                                        pattern: "^[a-z][a-z0-9_]*$"
+                                        type: "string"
                                     },
                                     dependencies: {
                                         description: "A list of other API endpoints that this scenario logically depends on.\n\nThese dependencies represent context or prerequisite conditions, such as\nauthentication, resource creation, or data setup, that are relevant to\nthe test. This list is not a strict execution order \u2014 if ordering is\nimportant, it must be described explicitly in the `purpose`.\n\nWARNING: Every endpoint referenced here MUST exist in the provided API\noperations. Do NOT reference endpoints that are not explicitly available,\neven if they seem logically necessary based on database schema or\nbusiness logic.",
@@ -841,7 +841,7 @@ const collection = {
                         }
                     },
                     description: "Make test scenarios for the given endpoints.",
-                    validate: (() => { const _io0 = input => Array.isArray(input.scenarioGroups) && input.scenarioGroups.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && (Array.isArray(input.scenarios) && (1 <= input.scenarios.length && input.scenarios.every(elem => "object" === typeof elem && null !== elem && _io3(elem)))); const _io2 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io3 = input => "string" === typeof input.draft && ("string" === typeof input.functionName && RegExp("^[a-z][a-z0-9_]*$").test(input.functionName)) && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))); const _io4 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && "string" === typeof input.purpose; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.scenarioGroups) || _report(_exceptionable, {
+                    validate: (() => { const _io0 = input => Array.isArray(input.scenarioGroups) && input.scenarioGroups.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && (Array.isArray(input.scenarios) && (1 <= input.scenarios.length && input.scenarios.every(elem => "object" === typeof elem && null !== elem && _io3(elem)))); const _io2 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io3 = input => "string" === typeof input.draft && "string" === typeof input.functionName && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))); const _io4 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && "string" === typeof input.purpose; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.scenarioGroups) || _report(_exceptionable, {
                             path: _path + ".scenarioGroups",
                             expected: "Array<IAutoBeTestScenarioApplication.IScenarioGroup>",
                             value: input.scenarioGroups
@@ -901,13 +901,9 @@ const collection = {
                             path: _path + ".draft",
                             expected: "string",
                             value: input.draft
-                        }), "string" === typeof input.functionName && (RegExp("^[a-z][a-z0-9_]*$").test(input.functionName) || _report(_exceptionable, {
+                        }), "string" === typeof input.functionName || _report(_exceptionable, {
                             path: _path + ".functionName",
-                            expected: "string & SnakePattern",
-                            value: input.functionName
-                        })) || _report(_exceptionable, {
-                            path: _path + ".functionName",
-                            expected: "(string & SnakePattern)",
+                            expected: "string",
                             value: input.functionName
                         }), (Array.isArray(input.dependencies) || _report(_exceptionable, {
                             path: _path + ".dependencies",

package/lib/orchestrate/test/orchestrateTestScenario.js.map

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

package/lib/{agent/src/orchestrate → orchestrate}/test/orchestrateTestWrite.js

@@ -48,6 +48,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.orchestrateTestWrite = orchestrateTestWrite;
 const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
 const typia_1 = __importDefault(require("typia"));
+const NamingConvention_1 = require("typia/lib/utils/NamingConvention");
 const uuid_1 = require("uuid");
 const assertSchemaModel_1 = require("../../context/assertSchemaModel");
 const executeCachedBatch_1 = require("../../utils/executeCachedBatch");
@@ -82,7 +83,7 @@ function orchestrateTestWrite(ctx, scenarios) {
                     event,
                 };
             }
-            catch (error) {
+            catch (_a) {
                 return null;
             }
         })));
@@ -102,6 +103,7 @@ function process(ctx, props) {
             controller: createController({
                 model: ctx.model,
                 build: (next) => {
+                    next.domain = NamingConvention_1.NamingConvention.snake(next.domain);
                     pointer.value = next;
                 },
             }),
@@ -165,15 +167,14 @@ const claude = {
                     },
                     domain: {
                         description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis \u2192 Domain identification \u2192 Test organization\nstructure",
-                        type: "string",
-                        pattern: "^[a-z][a-z0-9_]*$"
+                        type: "string"
                     },
                     draft: {
                         description: "Step 3: Initial TypeScript E2E test code implementation.\n\nAI generates the first working version of the test code based on the\nstrategic plan. This draft must be compilation-error-free and follow",
                         type: "string"
                     },
                     revise: {
-                        description: "Steps 4-5: Code review and final refinement process.\n\nContains the iterative improvement workflow that transforms the initial\ndraft into production-ready test code. This two-phase process ensures\nsystematic quality enhancement through comprehensive review followed by\ntargeted refinement based on identified issues.\n\nWorkflow: Draft \u2192 Review analysis \u2192 Final implementation",
+                        description: "Steps 4-5: Code review and final refinement process.\n\nContains the iterative improvement workflow that transforms the initial\ndraft into production-ready test code. The review phase identifies issues\nto fix or code to delete, followed by the final phase that produces\nthe polished, production-ready test implementation.\n\nWorkflow: Draft \u2192 Review analysis \u2192 Final implementation",
                         $ref: "#/$defs/IAutoBeTestWriteApplication.IReviseProps"
                     }
                 },
@@ -189,11 +190,11 @@ const claude = {
                         type: "object",
                         properties: {
                             review: {
-                                description: "Step 4: Code review and quality assessment.\n\nAI performs a thorough review of the draft implementation, examining:\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-",
+                                description: "Step 4: Code review and quality assessment.\n\n**\uD83D\uDEA8 TWO TYPES OF REVISIONS: FIX AND DELETE \uD83D\uDEA8**\n\nAI performs a thorough review of the draft implementation for:\n\n**1. FIX - Improve existing code:**\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-",
                                 type: "string"
                             },
                             final: {
-                                description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment. All identified issues\nmust be resolved, and the code must meet the highest quality standards.\n\nWorkflow: Review feedback \u2192 Code refinement \u2192 Production-ready\nimplementation\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite.",
+                                description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment.\n\n**\uD83D\uDEA8 CRITICAL: APPLY ALL FIXES AND DELETIONS FROM REVIEW \uD83D\uDEA8**\n\n- FIX all correctable issues identified in review\n- DELETE all prohibited code identified in review\n- If review found type error tests, they MUST be deleted in final\n- If review found code to DELETE, final MUST be different from draft\n\nAll identified issues must be resolved, and the code must meet the\nhighest quality standards.\n\nWorkflow: Review feedback \u2192 Apply FIXES \u2192 Apply DELETIONS \u2192\nProduction-ready implementation\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite.",
                                 type: "string"
                             }
                         },
@@ -205,17 +206,13 @@ const claude = {
                 }
             },
             description: "Main entry point for AI Function Call - generates complete E2E test code.\n\nThe AI executes this function to perform the entire test generation\nworkflow: scenario analysis \u2192 draft implementation \u2192 code review \u2192 final\ncode production. This structured approach ensures high-quality,\ncompilation-error-free test code.",
-            validate: (() => { const _io0 = input => "string" === typeof input.scenario && ("string" === typeof input.domain && RegExp("^[a-z][a-z0-9_]*$").test(input.domain)) && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise)); const _io1 = input => "string" === typeof input.review && "string" === typeof input.final; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.scenario || _report(_exceptionable, {
+            validate: (() => { const _io0 = input => "string" === typeof input.scenario && "string" === typeof input.domain && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise)); const _io1 = input => "string" === typeof input.review && "string" === typeof input.final; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.scenario || _report(_exceptionable, {
                     path: _path + ".scenario",
                     expected: "string",
                     value: input.scenario
-                }), "string" === typeof input.domain && (RegExp("^[a-z][a-z0-9_]*$").test(input.domain) || _report(_exceptionable, {
-                    path: _path + ".domain",
-                    expected: "string & SnakePattern",
-                    value: input.domain
-                })) || _report(_exceptionable, {
+                }), "string" === typeof input.domain || _report(_exceptionable, {
                     path: _path + ".domain",
-                    expected: "(string & SnakePattern)",
+                    expected: "string",
                     value: input.domain
                 }), "string" === typeof input.draft || _report(_exceptionable, {
                     path: _path + ".draft",
@@ -280,7 +277,7 @@ const collection = {
             {
                 name: "write",
                 parameters: {
-                    description: " Complete specification for test generation including scenario,\ndomain, and implementation steps\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Steps 4-5: Code review and final refinement process.\n> \n> Contains the iterative improvement workflow that transforms the initial\n> draft into production-ready test code. This two-phase process ensures\n> systematic quality enhancement through comprehensive review followed by\n> targeted refinement based on identified issues.\n> \n> Workflow: Draft \u2192 Review analysis \u2192 Final implementation",
+                    description: " Complete specification for test generation including scenario,\ndomain, and implementation steps\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Steps 4-5: Code review and final refinement process.\n> \n> Contains the iterative improvement workflow that transforms the initial\n> draft into production-ready test code. The review phase identifies issues\n> to fix or code to delete, followed by the final phase that produces\n> the polished, production-ready test implementation.\n> \n> Workflow: Draft \u2192 Review analysis \u2192 Final implementation",
                     type: "object",
                     properties: {
                         scenario: {
@@ -288,7 +285,7 @@ const collection = {
                             type: "string"
                         },
                         domain: {
-                            description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis \u2192 Domain identification \u2192 Test organization\nstructure\n\n\n@pattern ^[a-z][a-z0-9_]*$",
+                            description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis \u2192 Domain identification \u2192 Test organization\nstructure",
                             type: "string"
                         },
                         draft: {
@@ -311,11 +308,11 @@ const collection = {
                             type: "object",
                             properties: {
                                 review: {
-                                    description: "Step 4: Code review and quality assessment.\n\nAI performs a thorough review of the draft implementation, examining:\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-",
+                                    description: "Step 4: Code review and quality assessment.\n\n**\uD83D\uDEA8 TWO TYPES OF REVISIONS: FIX AND DELETE \uD83D\uDEA8**\n\nAI performs a thorough review of the draft implementation for:\n\n**1. FIX - Improve existing code:**\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-",
                                     type: "string"
                                 },
                                 final: {
-                                    description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment. All identified issues\nmust be resolved, and the code must meet the highest quality standards.\n\nWorkflow: Review feedback \u2192 Code refinement \u2192 Production-ready\nimplementation\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite.",
+                                    description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment.\n\n**\uD83D\uDEA8 CRITICAL: APPLY ALL FIXES AND DELETIONS FROM REVIEW \uD83D\uDEA8**\n\n- FIX all correctable issues identified in review\n- DELETE all prohibited code identified in review\n- If review found type error tests, they MUST be deleted in final\n- If review found code to DELETE, final MUST be different from draft\n\nAll identified issues must be resolved, and the code must meet the\nhighest quality standards.\n\nWorkflow: Review feedback \u2192 Apply FIXES \u2192 Apply DELETIONS \u2192\nProduction-ready implementation\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite.",
                                     type: "string"
                                 }
                             },
@@ -327,17 +324,13 @@ const collection = {
                     }
                 },
                 description: "Main entry point for AI Function Call - generates complete E2E test code.\n\nThe AI executes this function to perform the entire test generation\nworkflow: scenario analysis \u2192 draft implementation \u2192 code review \u2192 final\ncode production. This structured approach ensures high-quality,\ncompilation-error-free test code.",
-                validate: (() => { const _io0 = input => "string" === typeof input.scenario && ("string" === typeof input.domain && RegExp("^[a-z][a-z0-9_]*$").test(input.domain)) && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise)); const _io1 = input => "string" === typeof input.review && "string" === typeof input.final; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.scenario || _report(_exceptionable, {
+                validate: (() => { const _io0 = input => "string" === typeof input.scenario && "string" === typeof input.domain && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise)); const _io1 = input => "string" === typeof input.review && "string" === typeof input.final; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.scenario || _report(_exceptionable, {
                         path: _path + ".scenario",
                         expected: "string",
                         value: input.scenario
-                    }), "string" === typeof input.domain && (RegExp("^[a-z][a-z0-9_]*$").test(input.domain) || _report(_exceptionable, {
-                        path: _path + ".domain",
-                        expected: "string & SnakePattern",
-                        value: input.domain
-                    })) || _report(_exceptionable, {
+                    }), "string" === typeof input.domain || _report(_exceptionable, {
                         path: _path + ".domain",
-                        expected: "(string & SnakePattern)",
+                        expected: "string",
                         value: input.domain
                     }), "string" === typeof input.draft || _report(_exceptionable, {
                         path: _path + ".draft",
@@ -413,7 +406,6 @@ const collection = {
                         },
                         domain: {
                             type: "string",
-                            pattern: "^[a-z][a-z0-9_]*$",
                             description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis \u2192 Domain identification \u2192 Test organization\nstructure"
                         },
                         draft: {
@@ -425,18 +417,18 @@ const collection = {
                             properties: {
                                 review: {
                                     type: "string",
-                                    description: "Step 4: Code review and quality assessment.\n\nAI performs a thorough review of the draft implementation, examining:\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-"
+                                    description: "Step 4: Code review and quality assessment.\n\n**\uD83D\uDEA8 TWO TYPES OF REVISIONS: FIX AND DELETE \uD83D\uDEA8**\n\nAI performs a thorough review of the draft implementation for:\n\n**1. FIX - Improve existing code:**\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-"
                                 },
                                 final: {
                                     type: "string",
-                                    description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment. All identified issues\nmust be resolved, and the code must meet the highest quality standards.\n\nWorkflow: Review feedback \u2192 Code refinement \u2192 Production-ready\nimplementation\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite."
+                                    description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment.\n\n**\uD83D\uDEA8 CRITICAL: APPLY ALL FIXES AND DELETIONS FROM REVIEW \uD83D\uDEA8**\n\n- FIX all correctable issues identified in review\n- DELETE all prohibited code identified in review\n- If review found type error tests, they MUST be deleted in final\n- If review found code to DELETE, final MUST be different from draft\n\nAll identified issues must be resolved, and the code must meet the\nhighest quality standards.\n\nWorkflow: Review feedback \u2192 Apply FIXES \u2192 Apply DELETIONS \u2192\nProduction-ready implementation\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite."
                                 }
                             },
                             required: [
                                 "review",
                                 "final"
                             ],
-                            description: "Steps 4-5: Code review and final refinement process.\n\nContains the iterative improvement workflow that transforms the initial\ndraft into production-ready test code. This two-phase process ensures\nsystematic quality enhancement through comprehensive review followed by\ntargeted refinement based on identified issues.\n\nWorkflow: Draft \u2192 Review analysis \u2192 Final implementation\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IReviseProps}",
+                            description: "Steps 4-5: Code review and final refinement process.\n\nContains the iterative improvement workflow that transforms the initial\ndraft into production-ready test code. The review phase identifies issues\nto fix or code to delete, followed by the final phase that produces\nthe polished, production-ready test implementation.\n\nWorkflow: Draft \u2192 Review analysis \u2192 Final implementation\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IReviseProps}",
                             additionalProperties: false
                         }
                     },
@@ -450,17 +442,13 @@ const collection = {
                     additionalProperties: false
                 },
                 description: "Main entry point for AI Function Call - generates complete E2E test code.\n\nThe AI executes this function to perform the entire test generation\nworkflow: scenario analysis \u2192 draft implementation \u2192 code review \u2192 final\ncode production. This structured approach ensures high-quality,\ncompilation-error-free test code.",
-                validate: (() => { const _io0 = input => "string" === typeof input.scenario && ("string" === typeof input.domain && RegExp("^[a-z][a-z0-9_]*$").test(input.domain)) && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise)); const _io1 = input => "string" === typeof input.review && "string" === typeof input.final; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.scenario || _report(_exceptionable, {
+                validate: (() => { const _io0 = input => "string" === typeof input.scenario && "string" === typeof input.domain && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise)); const _io1 = input => "string" === typeof input.review && "string" === typeof input.final; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.scenario || _report(_exceptionable, {
                         path: _path + ".scenario",
                         expected: "string",
                         value: input.scenario
-                    }), "string" === typeof input.domain && (RegExp("^[a-z][a-z0-9_]*$").test(input.domain) || _report(_exceptionable, {
+                    }), "string" === typeof input.domain || _report(_exceptionable, {
                         path: _path + ".domain",
-                        expected: "string & SnakePattern",
-                        value: input.domain
-                    })) || _report(_exceptionable, {
-                        path: _path + ".domain",
-                        expected: "(string & SnakePattern)",
+                        expected: "string",
                         value: input.domain
                     }), "string" === typeof input.draft || _report(_exceptionable, {
                         path: _path + ".draft",

package/lib/orchestrate/test/orchestrateTestWrite.js.map

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

package/lib/orchestrate/test/structures/IAutoBeTestCorrectApplication.js.map

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

package/lib/orchestrate/test/structures/IAutoBeTestCorrectInvalidRequestApplication.d.ts

@@ -0,0 +1,140 @@
+export interface IAutoBeTestCorrectInvalidRequestApplication {
+    /**
+     * Rewrite function to remove code containing invalid type API requests.
+     *
+     * This function is called when the agent detects code that attempts to send
+     * API requests with deliberately wrong types, causing TypeScript compilation
+     * errors. The agent will remove the problematic code sections while
+     * preserving valid test code.
+     *
+     * Common patterns that trigger this function:
+     *
+     * - TestValidator.error calls testing type violations
+     * - Missing required fields with type assertions
+     * - Wrong type assignments with satisfies operator
+     * - Nested type violations in complex objects
+     * - Partial type testing with invalid structures
+     *
+     * The rationale for deletion:
+     *
+     * - Type validation is the server's responsibility, not E2E tests
+     * - TypeScript compiler should enforce type safety at compile time
+     * - Invalid type testing breaks the entire test suite compilation
+     * - E2E tests should focus on business logic, not type system violations
+     *
+     * @param props - The analysis and correction properties
+     * @param props.think - Analysis of what specific invalid request pattern is
+     *   causing the error
+     * @param props.draft - Initial corrected code with problematic sections
+     *   completely removed
+     * @param props.revise - Review process and final cleaned code
+     */
+    rewrite(props: IAutoBeTestCorrectInvalidRequestApplication.IProps): void;
+    /**
+     * Reject function when no invalid type API requests are detected.
+     *
+     * This function is called when the compilation error is not related to
+     * invalid API request types, indicating the agent should not intervene.
+     *
+     * Common scenarios for rejection:
+     *
+     * - Syntax errors unrelated to type violations
+     * - Legitimate type mismatches that need fixing (not deletion)
+     * - Framework-specific compilation issues
+     * - Configuration or environment problems
+     *
+     * When called, this indicates that another specialized agent should handle
+     * the compilation error, as it's outside this agent's domain.
+     */
+    reject(): void;
+}
+export declare namespace IAutoBeTestCorrectInvalidRequestApplication {
+    /**
+     * Properties for the rewrite function containing the analysis and correction
+     * workflow.
+     *
+     * This follows a three-phase approach: think → draft → revise, ensuring
+     * systematic removal of invalid type testing code while maintaining the
+     * integrity of valid E2E tests.
+     */
+    interface IProps {
+        /**
+         * Initial analysis phase.
+         *
+         * Contains the agent's analysis of what specific invalid request pattern
+         * was found in the code and how it's causing the compilation error. This
+         * should identify:
+         *
+         * - The exact pattern (as any, satisfies, TestValidator.error, etc.)
+         * - Line numbers and locations of violations
+         * - The TypeScript error codes being triggered
+         * - Why this constitutes invalid type testing
+         *
+         * Example: "Detected TestValidator.error() call at line 45 with 'as any'
+         * casting on request body containing deliberately wrong types (number for
+         * email field). This is causing TS2345 compilation error."
+         */
+        think: string;
+        /**
+         * Draft correction phase.
+         *
+         * The initial corrected code with the problematic API request sections
+         * completely removed while preserving all valid test code.
+         *
+         * Rules for drafting:
+         *
+         * - Remove entire test functions containing type violations
+         * - Do not comment out code - delete it completely
+         * - Preserve test suite structure and valid tests
+         * - Maintain proper indentation and formatting
+         * - Keep imports that are still needed by remaining code
+         */
+        draft: string;
+        /**
+         * Review and finalization phase.
+         *
+         * Contains the review of changes made and the final cleaned code that
+         * should compile without the invalid API request errors. This ensures the
+         * correction is complete and accurate.
+         */
+        revise: IReviseProps;
+    }
+    /**
+     * Properties for the revision phase of the correction process.
+     *
+     * This phase ensures that the removal was complete and the remaining code is
+     * valid and compilable.
+     */
+    interface IReviseProps {
+        /**
+         * Review of the changes made.
+         *
+         * Brief explanation of what invalid API request code was removed and
+         * verification that valid test code was preserved. Should confirm:
+         *
+         * - Which patterns were found and removed
+         * - Line ranges that were deleted
+         * - Verification that valid tests remain intact
+         * - Confirmation that no partial fixes were applied
+         *
+         * Example: "Removed lines 43-52 containing TestValidator.error with invalid
+         * type casting. Verified remaining tests are valid and unaffected."
+         */
+        review: string;
+        /**
+         * Final corrected code.
+         *
+         * The complete, cleaned test code with all invalid API request sections
+         * removed, ready for compilation.
+         *
+         * This code must:
+         *
+         * - Compile without TypeScript errors
+         * - Contain only valid business logic tests
+         * - Have no `as any` or similar type violations
+         * - Maintain the original file structure
+         * - Be production-ready E2E test code
+         */
+        final: string;
+    }
+}

package/lib/orchestrate/test/structures/IAutoBeTestCorrectInvalidRequestApplication.js

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

package/lib/orchestrate/test/structures/IAutoBeTestCorrectInvalidRequestApplication.js.map

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

package/lib/orchestrate/test/structures/IAutoBeTestFunction.js.map

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

package/lib/orchestrate/test/structures/IAutoBeTestFunctionFailure.js.map

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