@autobe/agent 0.17.1 → 0.19.1

package/lib/{orchestrate → agent/src/orchestrate}/realize/orchestrateRealizeAuthorizationCorrect.js

@@ -47,19 +47,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.orchestrateRealizeAuthorizationCorrect = orchestrateRealizeAuthorizationCorrect;
 const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
-const core_1 = require("@agentica/core");
 const typia_1 = __importDefault(require("typia"));
 const assertSchemaModel_1 = require("../../context/assertSchemaModel");
-const enforceToolCall_1 = require("../../utils/enforceToolCall");
-const transformRealizeAuthorizationCorrectHistories_1 = require("./transformRealizeAuthorizationCorrectHistories");
+const transformRealizeAuthorizationCorrectHistories_1 = require("./histories/transformRealizeAuthorizationCorrectHistories");
 const AuthorizationFileSystem_1 = require("./utils/AuthorizationFileSystem");
 const AutoBeRealizeAuthorizationReplaceImport_1 = require("./utils/AutoBeRealizeAuthorizationReplaceImport");
 function orchestrateRealizeAuthorizationCorrect(ctx_1, authorization_1, prismaClients_1, templateFiles_1) {
     return __awaiter(this, arguments, void 0, function* (ctx, authorization, prismaClients, templateFiles, life = 4) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         const compiler = yield ctx.compiler();
-        const providerContent = yield compiler.typescript.beautify(AutoBeRealizeAuthorizationReplaceImport_1.AutoBeRealizeAuthorizationReplaceImport.replaceProviderImport(authorization.role, authorization.provider.content));
-        const decoratorContent = yield compiler.typescript.beautify(AutoBeRealizeAuthorizationReplaceImport_1.AutoBeRealizeAuthorizationReplaceImport.replaceDecoratorImport(authorization.role, authorization.decorator.content));
+        const providerContent = yield compiler.typescript.beautify(AutoBeRealizeAuthorizationReplaceImport_1.AutoBeRealizeAuthorizationReplaceImport.replaceProviderImport(authorization.role.name, authorization.provider.content));
+        const decoratorContent = yield compiler.typescript.beautify(AutoBeRealizeAuthorizationReplaceImport_1.AutoBeRealizeAuthorizationReplaceImport.replaceDecoratorImport(authorization.role.name, authorization.decorator.content));
         // Check Compile
         const files = Object.assign(Object.assign(Object.assign({}, templateFiles), prismaClients), { [AuthorizationFileSystem_1.AuthorizationFileSystem.decoratorPath(authorization.decorator.name)]: decoratorContent, [AuthorizationFileSystem_1.AuthorizationFileSystem.providerPath(authorization.provider.name)]: providerContent, [AuthorizationFileSystem_1.AuthorizationFileSystem.payloadPath(authorization.payload.name)]: authorization.payload.content });
         const compiled = yield compiler.typescript.compile({
@@ -81,28 +79,17 @@ function orchestrateRealizeAuthorizationCorrect(ctx_1, authorization_1, prismaCl
         const pointer = {
             value: null,
         };
-        const agentica = new core_1.MicroAgentica({
-            model: ctx.model,
-            vendor: ctx.vendor,
-            config: Object.assign(Object.assign({}, ((_c = ctx.config) !== null && _c !== void 0 ? _c : {})), { executor: {
-                    describe: null,
-                } }),
+        const { tokenUsage } = yield ctx.conversate({
+            source: "realizeAuthorizationCorrect",
             histories: (0, transformRealizeAuthorizationCorrectHistories_1.transformRealizeAuthorizationCorrectHistories)(ctx, authorization, templateFiles, compiled.diagnostics),
-            controllers: [
-                createApplication({
-                    model: ctx.model,
-                    build: (next) => {
-                        pointer.value = next;
-                    },
-                }),
-            ],
-        });
-        (0, enforceToolCall_1.enforceToolCall)(agentica);
-        yield agentica
-            .conversate("Please correct the decorator and the provider.")
-            .finally(() => {
-            const tokenUsage = agentica.getTokenUsage().aggregate;
-            ctx.usage().record(tokenUsage, ["realize"]);
+            controller: createController({
+                model: ctx.model,
+                build: (next) => {
+                    pointer.value = next;
+                },
+            }),
+            enforceFunctionCall: true,
+            message: "Please correct the decorator and the provider.",
         });
         if (pointer.value === null)
             throw new Error("Failed to correct decorator.");
@@ -111,11 +98,11 @@ function orchestrateRealizeAuthorizationCorrect(ctx_1, authorization_1, prismaCl
                 location: AuthorizationFileSystem_1.AuthorizationFileSystem.payloadPath(pointer.value.payload.name),
                 content: yield compiler.typescript.beautify(pointer.value.payload.content),
             }, role: authorization.role });
-        ctx.dispatch(Object.assign(Object.assign({}, pointer.value), { type: "realizeAuthorizationCorrect", created_at: new Date().toISOString(), authorization: result, result: compiled, step: (_e = (_d = ctx.state().test) === null || _d === void 0 ? void 0 : _d.step) !== null && _e !== void 0 ? _e : 0 }));
+        ctx.dispatch(Object.assign(Object.assign({}, pointer.value), { type: "realizeAuthorizationCorrect", created_at: new Date().toISOString(), authorization: result, result: compiled, tokenUsage, step: (_d = (_c = ctx.state().test) === null || _c === void 0 ? void 0 : _c.step) !== null && _d !== void 0 ? _d : 0 }));
         return yield orchestrateRealizeAuthorizationCorrect(ctx, result, prismaClients, templateFiles, life - 1);
     });
 }
-function createApplication(props) {
+function createController(props) {
     (0, assertSchemaModel_1.assertSchemaModel)(props.model);
     const application = collection[props.model];
     return {
@@ -176,8 +163,9 @@ const claude = {
                         type: "object",
                         properties: {
                             name: {
-                                description: "The name of the authentication Provider function in {role}Authorize\nformat (e.g., adminAuthorize, userAuthorize). This function will be\ncalled by the decorator to verify JWT tokens and return authenticated\nuser information for the specified role.",
-                                type: "string"
+                                description: "The name of the authentication Provider function in {role}Authorize\nformat (e.g., adminAuthorize, userAuthorize). This function will be\ncalled by the decorator to verify JWT tokens and return authenticated\nuser information for the specified role.\n\nDO: Use camelCase naming convention.",
+                                type: "string",
+                                pattern: "^[a-z][a-zA-Z0-9]*$"
                             },
                             content: {
                                 description: "Complete TypeScript code for the authentication Provider function. Must\ninclude: JWT token verification using jwtAuthorize function, role type\nchecking against payload.type, database query using\nMyGlobal.prisma.{tableName} pattern to verify user existence, and proper\nerror handling with ForbiddenException and UnauthorizedException. The\nfunction should return the authenticated user payload data.",
@@ -193,8 +181,9 @@ const claude = {
                         type: "object",
                         properties: {
                             name: {
-                                description: "The name of the Decorator to be generated in {Role}Auth format (e.g.,\nAdminAuth, UserAuth). This decorator will be used as a parameter\ndecorator in Controller methods to automatically authenticate and\nauthorize users for the specific role, injecting the authenticated user\npayload as a method parameter.",
-                                type: "string"
+                                description: "The name of the Decorator to be generated in {Role}Auth format (e.g.,\nAdminAuth, UserAuth). This decorator will be used as a parameter\ndecorator in Controller methods to automatically authenticate and\nauthorize users for the specific role, injecting the authenticated user\npayload as a method parameter.\n\nDO: Use PascalCase naming convention.",
+                                type: "string",
+                                pattern: "^[A-Z][a-zA-Z0-9]*$"
                             },
                             content: {
                                 description: "Complete TypeScript code for the authentication Decorator implementation.\nMust include: SwaggerCustomizer integration to add bearer token security\nschema to API documentation, createParamDecorator implementation that\ncalls the corresponding Provider function for authentication, Singleton\npattern using tstl library for efficient decorator instance management,\nand proper TypeScript typing for the ParameterDecorator interface.",
@@ -210,8 +199,9 @@ const claude = {
                         type: "object",
                         properties: {
                             name: {
-                                description: "The name of the Payload type to be generated in {Role}Payload format\n(e.g., AdminPayload, UserPayload). This type defines the structure of the\nauthenticated user data that will be injected into Controller methods\nwhen using the decorator.",
-                                type: "string"
+                                description: "The name of the Payload type to be generated in {Role}Payload format\n(e.g., AdminPayload, UserPayload). This type defines the structure of the\nauthenticated user data that will be injected into Controller methods\nwhen using the decorator.\n\nDO: Use PascalCase naming convention.",
+                                type: "string",
+                                pattern: "^[A-Z][a-zA-Z0-9]*$"
                             },
                             content: {
                                 description: "Complete TypeScript code for the Payload type interface in {Role}Payload\nformat (e.g., AdminPayload, UserPayload). Must include: id field with\nUUID format validation, type field as role discriminator, and proper\ntypia tags for validation. This interface defines the structure of the\nauthenticated user data that will be injected into Controller methods\nwhen using the decorator and serves as the TypeScript type for the\nparameter in Controller method signatures.",
@@ -225,7 +215,7 @@ const claude = {
                     }
                 }
             },
-            validate: (() => { const _io0 = input => "string" === typeof input.error_analysis && "string" === typeof input.solution_guidance && ("object" === typeof input.provider && null !== input.provider && _io1(input.provider)) && ("object" === typeof input.decorator && null !== input.decorator && _io2(input.decorator)) && ("object" === typeof input.payload && null !== input.payload && _io3(input.payload)); const _io1 = input => "string" === typeof input.name && "string" === typeof input.content; const _io2 = input => "string" === typeof input.name && "string" === typeof input.content; const _io3 = input => "string" === typeof input.name && "string" === typeof input.content; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.error_analysis || _report(_exceptionable, {
+            validate: (() => { const _io0 = input => "string" === typeof input.error_analysis && "string" === typeof input.solution_guidance && ("object" === typeof input.provider && null !== input.provider && _io1(input.provider)) && ("object" === typeof input.decorator && null !== input.decorator && _io2(input.decorator)) && ("object" === typeof input.payload && null !== input.payload && _io3(input.payload)); const _io1 = input => "string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.content; const _io2 = input => "string" === typeof input.name && RegExp("^[A-Z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.content; const _io3 = input => "string" === typeof input.name && RegExp("^[A-Z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.content; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.error_analysis || _report(_exceptionable, {
                     path: _path + ".error_analysis",
                     expected: "string",
                     value: input.error_analysis
@@ -257,25 +247,37 @@ const claude = {
                     path: _path + ".payload",
                     expected: "IAutoBeRealizeAuthorizationApplication.IPayloadType",
                     value: input.payload
-                })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name || _report(_exceptionable, {
+                })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) || _report(_exceptionable, {
                     path: _path + ".name",
-                    expected: "string",
+                    expected: "string & CamelPattern",
+                    value: input.name
+                })) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "(string & CamelPattern)",
                     value: input.name
                 }), "string" === typeof input.content || _report(_exceptionable, {
                     path: _path + ".content",
                     expected: "string",
                     value: input.content
-                })].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.name || _report(_exceptionable, {
+                })].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[A-Z][a-zA-Z0-9]*$").test(input.name) || _report(_exceptionable, {
                     path: _path + ".name",
-                    expected: "string",
+                    expected: "string & PascalPattern",
+                    value: input.name
+                })) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "(string & PascalPattern)",
                     value: input.name
                 }), "string" === typeof input.content || _report(_exceptionable, {
                     path: _path + ".content",
                     expected: "string",
                     value: input.content
-                })].every(flag => flag); const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.name || _report(_exceptionable, {
+                })].every(flag => flag); const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[A-Z][a-zA-Z0-9]*$").test(input.name) || _report(_exceptionable, {
                     path: _path + ".name",
-                    expected: "string",
+                    expected: "string & PascalPattern",
+                    value: input.name
+                })) || _report(_exceptionable, {
+                    path: _path + ".name",
+                    expected: "(string & PascalPattern)",
                     value: input.name
                 }), "string" === typeof input.content || _report(_exceptionable, {
                     path: _path + ".content",
@@ -358,7 +360,7 @@ const collection = {
                             type: "object",
                             properties: {
                                 name: {
-                                    description: "The name of the authentication Provider function in {role}Authorize\nformat (e.g., adminAuthorize, userAuthorize). This function will be\ncalled by the decorator to verify JWT tokens and return authenticated\nuser information for the specified role.",
+                                    description: "The name of the authentication Provider function in {role}Authorize\nformat (e.g., adminAuthorize, userAuthorize). This function will be\ncalled by the decorator to verify JWT tokens and return authenticated\nuser information for the specified role.\n\nDO: Use camelCase naming convention.\n\n\n@pattern ^[a-z][a-zA-Z0-9]*$",
                                     type: "string"
                                 },
                                 content: {
@@ -375,7 +377,7 @@ const collection = {
                             type: "object",
                             properties: {
                                 name: {
-                                    description: "The name of the Decorator to be generated in {Role}Auth format (e.g.,\nAdminAuth, UserAuth). This decorator will be used as a parameter\ndecorator in Controller methods to automatically authenticate and\nauthorize users for the specific role, injecting the authenticated user\npayload as a method parameter.",
+                                    description: "The name of the Decorator to be generated in {Role}Auth format (e.g.,\nAdminAuth, UserAuth). This decorator will be used as a parameter\ndecorator in Controller methods to automatically authenticate and\nauthorize users for the specific role, injecting the authenticated user\npayload as a method parameter.\n\nDO: Use PascalCase naming convention.\n\n\n@pattern ^[A-Z][a-zA-Z0-9]*$",
                                     type: "string"
                                 },
                                 content: {
@@ -392,7 +394,7 @@ const collection = {
                             type: "object",
                             properties: {
                                 name: {
-                                    description: "The name of the Payload type to be generated in {Role}Payload format\n(e.g., AdminPayload, UserPayload). This type defines the structure of the\nauthenticated user data that will be injected into Controller methods\nwhen using the decorator.",
+                                    description: "The name of the Payload type to be generated in {Role}Payload format\n(e.g., AdminPayload, UserPayload). This type defines the structure of the\nauthenticated user data that will be injected into Controller methods\nwhen using the decorator.\n\nDO: Use PascalCase naming convention.\n\n\n@pattern ^[A-Z][a-zA-Z0-9]*$",
                                     type: "string"
                                 },
                                 content: {
@@ -407,7 +409,7 @@ const collection = {
                         }
                     }
                 },
-                validate: (() => { const _io0 = input => "string" === typeof input.error_analysis && "string" === typeof input.solution_guidance && ("object" === typeof input.provider && null !== input.provider && _io1(input.provider)) && ("object" === typeof input.decorator && null !== input.decorator && _io2(input.decorator)) && ("object" === typeof input.payload && null !== input.payload && _io3(input.payload)); const _io1 = input => "string" === typeof input.name && "string" === typeof input.content; const _io2 = input => "string" === typeof input.name && "string" === typeof input.content; const _io3 = input => "string" === typeof input.name && "string" === typeof input.content; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.error_analysis || _report(_exceptionable, {
+                validate: (() => { const _io0 = input => "string" === typeof input.error_analysis && "string" === typeof input.solution_guidance && ("object" === typeof input.provider && null !== input.provider && _io1(input.provider)) && ("object" === typeof input.decorator && null !== input.decorator && _io2(input.decorator)) && ("object" === typeof input.payload && null !== input.payload && _io3(input.payload)); const _io1 = input => "string" === typeof input.name && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.content; const _io2 = input => "string" === typeof input.name && RegExp("^[A-Z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.content; const _io3 = input => "string" === typeof input.name && RegExp("^[A-Z][a-zA-Z0-9]*$").test(input.name) && "string" === typeof input.content; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.error_analysis || _report(_exceptionable, {
                         path: _path + ".error_analysis",
                         expected: "string",
                         value: input.error_analysis
@@ -439,25 +441,37 @@ const collection = {
                         path: _path + ".payload",
                         expected: "IAutoBeRealizeAuthorizationApplication.IPayloadType",
                         value: input.payload
-                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name || _report(_exceptionable, {
+                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) || _report(_exceptionable, {
                         path: _path + ".name",
-                        expected: "string",
+                        expected: "string & CamelPattern",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & CamelPattern)",
                         value: input.name
                     }), "string" === typeof input.content || _report(_exceptionable, {
                         path: _path + ".content",
                         expected: "string",
                         value: input.content
-                    })].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.name || _report(_exceptionable, {
+                    })].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[A-Z][a-zA-Z0-9]*$").test(input.name) || _report(_exceptionable, {
                         path: _path + ".name",
-                        expected: "string",
+                        expected: "string & PascalPattern",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & PascalPattern)",
                         value: input.name
                     }), "string" === typeof input.content || _report(_exceptionable, {
                         path: _path + ".content",
                         expected: "string",
                         value: input.content
-                    })].every(flag => flag); const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.name || _report(_exceptionable, {
+                    })].every(flag => flag); const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (RegExp("^[A-Z][a-zA-Z0-9]*$").test(input.name) || _report(_exceptionable, {
                         path: _path + ".name",
-                        expected: "string",
+                        expected: "string & PascalPattern",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & PascalPattern)",
                         value: input.name
                     }), "string" === typeof input.content || _report(_exceptionable, {
                         path: _path + ".content",

package/lib/agent/src/orchestrate/realize/orchestrateRealizeAuthorizationCorrect.js.map

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

package/lib/agent/src/orchestrate/realize/orchestrateRealizeCorrect.d.ts

@@ -0,0 +1,16 @@
+import { AutoBeRealizeAuthorization, AutoBeRealizeCorrectEvent, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+export declare function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, props: {
+    authorization: AutoBeRealizeAuthorization | null;
+    totalAuthorizations: AutoBeRealizeAuthorization[];
+    scenario: IAutoBeRealizeScenarioApplication.IProps;
+    code: string;
+    diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+    progress: IProgress;
+}): Promise<AutoBeRealizeCorrectEvent>;
+export interface IProgress {
+    total: number;
+    completed: number;
+}