@autobe/agent 0.17.1 → 0.19.1

package/lib/{orchestrate → agent/src/orchestrate}/prisma/orchestratePrisma.js

@@ -10,12 +10,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.orchestratePrisma = void 0;
+const uuid_1 = require("uuid");
+const predicateStateMessage_1 = require("../../utils/predicateStateMessage");
 const orchestratePrismaComponent_1 = require("./orchestratePrismaComponent");
 const orchestratePrismaCorrect_1 = require("./orchestratePrismaCorrect");
+const orchestratePrismaReview_1 = require("./orchestratePrismaReview");
 const orchestratePrismaSchemas_1 = require("./orchestratePrismaSchemas");
 const orchestratePrisma = (ctx, props) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c, _d;
+    // PREDICATION
     const start = new Date();
+    const predicate = (0, predicateStateMessage_1.predicateStateMessage)(ctx.state(), "prisma");
+    if (predicate !== null)
+        return ctx.assistantMessage({
+            type: "assistantMessage",
+            id: (0, uuid_1.v4)(),
+            created_at: start.toISOString(),
+            text: predicate,
+            completed_at: new Date().toISOString(),
+        });
     ctx.dispatch({
         type: "prismaStart",
         created_at: start.toISOString(),
@@ -23,29 +36,42 @@ const orchestratePrisma = (ctx, props) => __awaiter(void 0, void 0, void 0, func
         step: (_b = (_a = ctx.state().analyze) === null || _a === void 0 ? void 0 : _a.step) !== null && _b !== void 0 ? _b : 0,
     });
     // COMPONENTS
-    const components = yield (0, orchestratePrismaComponent_1.orchestratePrismaComponents)(ctx);
-    if (components.type === "assistantMessage")
-        return ctx.assistantMessage(components);
-    else
-        ctx.dispatch(components);
+    const componentEvent = yield (0, orchestratePrismaComponent_1.orchestratePrismaComponents)(ctx);
+    ctx.dispatch(componentEvent);
     // CONSTRUCT AST DATA
-    const events = yield (0, orchestratePrismaSchemas_1.orchestratePrismaSchemas)(ctx, components.components);
-    // VALIDATE
-    const result = yield (0, orchestratePrismaCorrect_1.orchestratePrismaCorrect)(ctx, {
-        files: events.map((e) => e.file),
-    });
-    // COMPILE
+    const schemaEvents = yield (0, orchestratePrismaSchemas_1.orchestratePrismaSchemas)(ctx, componentEvent.components);
+    const application = {
+        files: schemaEvents.map((e) => e.file),
+    };
+    // REVIEW
     const compiler = yield ctx.compiler();
-    const schemas = yield compiler.prisma.write(result.data, "postgres");
+    const reviewSchemas = yield compiler.prisma.write(application, "postgres");
+    const reviewEvents = yield (0, orchestratePrismaReview_1.orchestratePrismaReview)(ctx, application, reviewSchemas, componentEvent.components);
+    for (const event of reviewEvents) {
+        const file = application.files.find((f) => f.filename === event.filename);
+        if (file === undefined)
+            continue;
+        for (const modification of event.modifications) {
+            const index = file.models.findIndex((m) => m.name === modification.name);
+            if (index === -1)
+                file.models.push(modification);
+            else
+                file.models[index] = modification;
+        }
+    }
+    // VALIDATE
+    const result = yield (0, orchestratePrismaCorrect_1.orchestratePrismaCorrect)(ctx, application);
+    const finalSchemas = yield compiler.prisma.write(result.data, "postgres");
     // PROPAGATE
     return ctx.dispatch({
         type: "prismaComplete",
         result,
-        schemas,
+        schemas: finalSchemas,
         compiled: yield compiler.prisma.compile({
-            files: schemas,
+            files: finalSchemas,
         }),
         step: (_d = (_c = ctx.state().analyze) === null || _c === void 0 ? void 0 : _c.step) !== null && _d !== void 0 ? _d : 0,
+        elapsed: new Date().getTime() - start.getTime(),
         created_at: new Date().toISOString(),
     });
 });

package/lib/agent/src/orchestrate/prisma/orchestratePrisma.js.map

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

package/lib/agent/src/orchestrate/prisma/orchestratePrismaComponent.d.ts

@@ -0,0 +1,4 @@
+import { AutoBePrismaComponentsEvent } from "@autobe/interface/src/events/AutoBePrismaComponentsEvent";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare function orchestratePrismaComponents<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, message?: string): Promise<AutoBePrismaComponentsEvent>;

package/lib/{orchestrate → agent/src/orchestrate}/prisma/orchestratePrismaComponent.js

@@ -47,46 +47,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.orchestratePrismaComponents = orchestratePrismaComponents;
 const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
-const core_1 = require("@agentica/core");
 const typia_1 = __importDefault(require("typia"));
-const uuid_1 = require("uuid");
 const assertSchemaModel_1 = require("../../context/assertSchemaModel");
 const transformPrismaComponentsHistories_1 = require("./histories/transformPrismaComponentsHistories");
 function orchestratePrismaComponents(ctx_1) {
-    return __awaiter(this, arguments, void 0, function* (ctx, content = "Please extract files and tables from the given documents.") {
-        var _a, _b, _c, _d, _e, _f;
+    return __awaiter(this, arguments, void 0, function* (ctx, message = "Design database from the given requirement analysis documents.") {
+        var _a, _b, _c, _d;
         const start = new Date();
         const pointer = {
             value: null,
         };
         const prefix = (_b = (_a = ctx.state().analyze) === null || _a === void 0 ? void 0 : _a.prefix) !== null && _b !== void 0 ? _b : 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: "prismaComponents",
             histories: (0, transformPrismaComponentsHistories_1.transformPrismaComponentsHistories)(ctx.state(), prefix),
-            controllers: [
-                createApplication({
-                    model: ctx.model,
-                    build: (next) => {
-                        pointer.value = next;
-                    },
-                }),
-            ],
-        });
-        const histories = yield agentica
-            .conversate(content)
-            .finally(() => {
-            const tokenUsage = agentica.getTokenUsage().aggregate;
-            ctx.usage().record(tokenUsage, ["prisma"]);
+            controller: createController({
+                model: ctx.model,
+                build: (next) => {
+                    pointer.value = next;
+                },
+            }),
+            enforceFunctionCall: true,
+            message,
         });
-        if (((_d = histories.at(-1)) === null || _d === void 0 ? void 0 : _d.type) === "assistantMessage")
-            return Object.assign(Object.assign({}, histories.at(-1)), { created_at: start.toISOString(), completed_at: new Date().toISOString(), id: (0, uuid_1.v4)() });
-        else if (pointer.value === null) {
+        if (pointer.value === null)
             throw new Error("Failed to extract files and tables."); // unreachable
-        }
         return {
             type: "prismaComponents",
             created_at: start.toISOString(),
@@ -94,11 +79,12 @@ function orchestratePrismaComponents(ctx_1) {
             review: pointer.value.review,
             decision: pointer.value.decision,
             components: pointer.value.components,
-            step: (_f = (_e = ctx.state().analyze) === null || _e === void 0 ? void 0 : _e.step) !== null && _f !== void 0 ? _f : 0,
+            tokenUsage,
+            step: (_d = (_c = ctx.state().analyze) === null || _c === void 0 ? void 0 : _c.step) !== null && _d !== void 0 ? _d : 0,
         };
     });
 }
-function createApplication(props) {
+function createController(props) {
     (0, assertSchemaModel_1.assertSchemaModel)(props.model);
     const application = collection[props.model];
     return {
@@ -142,7 +128,8 @@ const claude = {
                         type: "array",
                         items: {
                             $ref: "#/$defs/AutoBePrisma.IComponent"
-                        }
+                        },
+                        minItems: 1
                     }
                 },
                 required: [
@@ -200,7 +187,7 @@ const claude = {
                 }
             },
             description: "Organizes database tables into domain-based components for Prisma schema\ngeneration.\n\nTakes business requirements and groups related tables into logical domains,\nwith each component becoming a separate .prisma file.",
-            validate: (() => { const _io0 = input => "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.decision && (Array.isArray(input.components) && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.rationale && (Array.isArray(input.tables) && (1 <= input.tables.length && input.tables.every(elem => "string" === typeof elem && RegExp("^[a-z][a-z0-9_]*$").test(elem)))); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.thinking || _report(_exceptionable, {
+            validate: (() => { const _io0 = input => "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.decision && (Array.isArray(input.components) && (1 <= input.components.length && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem)))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.rationale && (Array.isArray(input.tables) && (1 <= input.tables.length && input.tables.every(elem => "string" === typeof elem && RegExp("^[a-z][a-z0-9_]*$").test(elem)))); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.thinking || _report(_exceptionable, {
                     path: _path + ".thinking",
                     expected: "string",
                     value: input.thinking
@@ -214,7 +201,11 @@ const claude = {
                     value: input.decision
                 }), (Array.isArray(input.components) || _report(_exceptionable, {
                     path: _path + ".components",
-                    expected: "Array<AutoBePrisma.IComponent>",
+                    expected: "(Array<AutoBePrisma.IComponent> & MinItems<1>)",
+                    value: input.components
+                })) && ((1 <= input.components.length || _report(_exceptionable, {
+                    path: _path + ".components",
+                    expected: "Array<> & MinItems<1>",
                     value: input.components
                 })) && input.components.map((elem, _index3) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
                     path: _path + ".components[" + _index3 + "]",
@@ -224,9 +215,9 @@ const claude = {
                     path: _path + ".components[" + _index3 + "]",
                     expected: "AutoBePrisma.IComponent",
                     value: elem
-                })).every(flag => flag) || _report(_exceptionable, {
+                })).every(flag => flag)) || _report(_exceptionable, {
                     path: _path + ".components",
-                    expected: "Array<AutoBePrisma.IComponent>",
+                    expected: "(Array<AutoBePrisma.IComponent> & MinItems<1>)",
                     value: input.components
                 })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename && (RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) || _report(_exceptionable, {
                     path: _path + ".filename",
@@ -254,7 +245,7 @@ const claude = {
                     value: input.rationale
                 }), (Array.isArray(input.tables) || _report(_exceptionable, {
                     path: _path + ".tables",
-                    expected: "(Array<string & Pattern<\"^[a-z][a-z0-9_]*$\">> & MinItems<1>)",
+                    expected: "(Array<string & SnakePattern> & MinItems<1>)",
                     value: input.tables
                 })) && ((1 <= input.tables.length || _report(_exceptionable, {
                     path: _path + ".tables",
@@ -262,15 +253,15 @@ const claude = {
                     value: input.tables
                 })) && input.tables.map((elem, _index4) => "string" === typeof elem && (RegExp("^[a-z][a-z0-9_]*$").test(elem) || _report(_exceptionable, {
                     path: _path + ".tables[" + _index4 + "]",
-                    expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                    expected: "string & SnakePattern",
                     value: elem
                 })) || _report(_exceptionable, {
                     path: _path + ".tables[" + _index4 + "]",
-                    expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                    expected: "(string & SnakePattern)",
                     value: elem
                 })).every(flag => flag)) || _report(_exceptionable, {
                     path: _path + ".tables",
-                    expected: "(Array<string & Pattern<\"^[a-z][a-z0-9_]*$\">> & MinItems<1>)",
+                    expected: "(Array<string & SnakePattern> & MinItems<1>)",
                     value: input.tables
                 })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
                 if (false === __is(input)) {
@@ -331,7 +322,7 @@ const collection = {
                             type: "string"
                         },
                         components: {
-                            description: "Array of domain components that group related database tables.\n\nEach component represents a business domain and becomes one Prisma schema\nfile. Common domains include: Actors (users), Sales (products), Orders,\nCarts, etc.\n\n**Example:**\n\n```typescript\n{\n  \"components\": [\n    {\n      \"filename\": \"schema-02-systematic.prisma\",\n      \"namespace\": \"Systematic\",\n      \"thinking\": \"These tables all relate to system configuration and channel management. They form the foundation of the platform.\",\n      \"review\": \"Considering the relationships, shopping_channel_categories connects channels and sales, but it fundamentally defines channel structure.\",\n      \"rationale\": \"Grouping all system configuration tables together provides a clear foundation layer that other domains can reference.\",\n      \"tables\": [\n        \"shopping_channels\",\n        \"shopping_sections\",\n        \"shopping_channel_categories\"\n      ]\n    },\n    {\n      \"filename\": \"schema-03-actors.prisma\",\n      \"namespace\": \"Actors\",\n      \"thinking\": \"All user-related entities should be grouped together as they share authentication and identity patterns.\",\n      \"review\": \"While customers interact with sales, the customer entity itself is about identity, not transactions.\",\n      \"rationale\": \"This component groups all actor-related tables to maintain separation between identity management and business transactions.\",\n      \"tables\": [\n        \"shopping_customers\",\n        \"shopping_citizens\",\n        \"shopping_administrators\"\n      ]\n    },\n    {\n      \"filename\": \"schema-04-sales.prisma\",\n      \"namespace\": \"Sales\",\n      \"thinking\": \"Product catalog and sales-related tables belong together as they form the core commerce functionality.\",\n      \"review\": \"Sales snapshots are integral to the sales domain for tracking product history and price changes.\",\n      \"rationale\": \"Consolidating all sales-related tables enables coherent management of the entire product lifecycle.\",\n      \"tables\": [\n        \"shopping_sales\",\n        \"shopping_sale_snapshots\",\n        \"shopping_sale_units\",\n        \"shopping_sale_unit_options\"\n      ]\n    }\n  ]\n}\n```\n\n**Notes:**\n\n- Table names must follow snake_case convention with domain prefix (e.g.,\n  `shopping_customers`)\n- Each component becomes one `.prisma` file containing related models\n- Filename numbering indicates dependency order for schema generation\n- Namespace is used for documentation organization and domain grouping",
+                            description: "Array of domain components that group related database tables.\n\nEach component represents a business domain and becomes one Prisma schema\nfile. Common domains include: Actors (users), Sales (products), Orders,\nCarts, etc.\n\n**Example:**\n\n```typescript\n{\n  \"components\": [\n    {\n      \"filename\": \"schema-02-systematic.prisma\",\n      \"namespace\": \"Systematic\",\n      \"thinking\": \"These tables all relate to system configuration and channel management. They form the foundation of the platform.\",\n      \"review\": \"Considering the relationships, shopping_channel_categories connects channels and sales, but it fundamentally defines channel structure.\",\n      \"rationale\": \"Grouping all system configuration tables together provides a clear foundation layer that other domains can reference.\",\n      \"tables\": [\n        \"shopping_channels\",\n        \"shopping_sections\",\n        \"shopping_channel_categories\"\n      ]\n    },\n    {\n      \"filename\": \"schema-03-actors.prisma\",\n      \"namespace\": \"Actors\",\n      \"thinking\": \"All user-related entities should be grouped together as they share authentication and identity patterns.\",\n      \"review\": \"While customers interact with sales, the customer entity itself is about identity, not transactions.\",\n      \"rationale\": \"This component groups all actor-related tables to maintain separation between identity management and business transactions.\",\n      \"tables\": [\n        \"shopping_customers\",\n        \"shopping_citizens\",\n        \"shopping_administrators\"\n      ]\n    },\n    {\n      \"filename\": \"schema-04-sales.prisma\",\n      \"namespace\": \"Sales\",\n      \"thinking\": \"Product catalog and sales-related tables belong together as they form the core commerce functionality.\",\n      \"review\": \"Sales snapshots are integral to the sales domain for tracking product history and price changes.\",\n      \"rationale\": \"Consolidating all sales-related tables enables coherent management of the entire product lifecycle.\",\n      \"tables\": [\n        \"shopping_sales\",\n        \"shopping_sale_snapshots\",\n        \"shopping_sale_units\",\n        \"shopping_sale_unit_options\"\n      ]\n    }\n  ]\n}\n```\n\n**Notes:**\n\n- Table names must follow snake_case convention with domain prefix (e.g.,\n  `shopping_customers`)\n- Each component becomes one `.prisma` file containing related models\n- Filename numbering indicates dependency order for schema generation\n- Namespace is used for documentation organization and domain grouping\n\n\n@minItems 1",
                             type: "array",
                             items: {
                                 $ref: "#/$defs/AutoBePrisma.IComponent"
@@ -391,7 +382,7 @@ const collection = {
                     }
                 },
                 description: "Organizes database tables into domain-based components for Prisma schema\ngeneration.\n\nTakes business requirements and groups related tables into logical domains,\nwith each component becoming a separate .prisma file.",
-                validate: (() => { const _io0 = input => "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.decision && (Array.isArray(input.components) && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.rationale && (Array.isArray(input.tables) && (1 <= input.tables.length && input.tables.every(elem => "string" === typeof elem && RegExp("^[a-z][a-z0-9_]*$").test(elem)))); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.thinking || _report(_exceptionable, {
+                validate: (() => { const _io0 = input => "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.decision && (Array.isArray(input.components) && (1 <= input.components.length && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem)))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.rationale && (Array.isArray(input.tables) && (1 <= input.tables.length && input.tables.every(elem => "string" === typeof elem && RegExp("^[a-z][a-z0-9_]*$").test(elem)))); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.thinking || _report(_exceptionable, {
                         path: _path + ".thinking",
                         expected: "string",
                         value: input.thinking
@@ -405,7 +396,11 @@ const collection = {
                         value: input.decision
                     }), (Array.isArray(input.components) || _report(_exceptionable, {
                         path: _path + ".components",
-                        expected: "Array<AutoBePrisma.IComponent>",
+                        expected: "(Array<AutoBePrisma.IComponent> & MinItems<1>)",
+                        value: input.components
+                    })) && ((1 <= input.components.length || _report(_exceptionable, {
+                        path: _path + ".components",
+                        expected: "Array<> & MinItems<1>",
                         value: input.components
                     })) && input.components.map((elem, _index3) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
                         path: _path + ".components[" + _index3 + "]",
@@ -415,9 +410,9 @@ const collection = {
                         path: _path + ".components[" + _index3 + "]",
                         expected: "AutoBePrisma.IComponent",
                         value: elem
-                    })).every(flag => flag) || _report(_exceptionable, {
+                    })).every(flag => flag)) || _report(_exceptionable, {
                         path: _path + ".components",
-                        expected: "Array<AutoBePrisma.IComponent>",
+                        expected: "(Array<AutoBePrisma.IComponent> & MinItems<1>)",
                         value: input.components
                     })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename && (RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) || _report(_exceptionable, {
                         path: _path + ".filename",
@@ -445,7 +440,7 @@ const collection = {
                         value: input.rationale
                     }), (Array.isArray(input.tables) || _report(_exceptionable, {
                         path: _path + ".tables",
-                        expected: "(Array<string & Pattern<\"^[a-z][a-z0-9_]*$\">> & MinItems<1>)",
+                        expected: "(Array<string & SnakePattern> & MinItems<1>)",
                         value: input.tables
                     })) && ((1 <= input.tables.length || _report(_exceptionable, {
                         path: _path + ".tables",
@@ -453,15 +448,15 @@ const collection = {
                         value: input.tables
                     })) && input.tables.map((elem, _index4) => "string" === typeof elem && (RegExp("^[a-z][a-z0-9_]*$").test(elem) || _report(_exceptionable, {
                         path: _path + ".tables[" + _index4 + "]",
-                        expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                        expected: "string & SnakePattern",
                         value: elem
                     })) || _report(_exceptionable, {
                         path: _path + ".tables[" + _index4 + "]",
-                        expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                        expected: "(string & SnakePattern)",
                         value: elem
                     })).every(flag => flag)) || _report(_exceptionable, {
                         path: _path + ".tables",
-                        expected: "(Array<string & Pattern<\"^[a-z][a-z0-9_]*$\">> & MinItems<1>)",
+                        expected: "(Array<string & SnakePattern> & MinItems<1>)",
                         value: input.tables
                     })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
                     if (false === __is(input)) {

package/lib/agent/src/orchestrate/prisma/orchestratePrismaComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestratePrismaComponent.js","sourceRoot":"","sources":["../../../../../src/orchestrate/prisma/orchestratePrismaComponent.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA,kEAmCC;;AA1CD,kDAA0B;AAG1B,uEAAoE;AACpE,uGAAoG;AAGpG,SAAsB,2BAA2B;yDAG/C,GAAyB,EACzB,UAAkB,gEAAgE;;QAElF,MAAM,KAAK,GAAS,IAAI,IAAI,EAAE,CAAC;QAC/B,MAAM,OAAO,GAA8D;YACzE,KAAK,EAAE,IAAI;SACZ,CAAC;QACF,MAAM,MAAM,GAAkB,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,MAAM,mCAAI,IAAI,CAAC;QAClE,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;YAC1C,MAAM,EAAE,kBAAkB;YAC1B,SAAS,EAAE,IAAA,uEAAkC,EAAC,GAAG,CAAC,KAAK,EAAE,EAAE,MAAM,CAAC;YAClE,UAAU,EAAE,gBAAgB,CAAC;gBAC3B,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE;oBACd,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;gBACvB,CAAC;aACF,CAAC;YACF,mBAAmB,EAAE,IAAI;YACzB,OAAO;SACR,CAAC,CAAC;QACH,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI;YACxB,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC,CAAC,cAAc;QACxE,OAAO;YACL,IAAI,EAAE,kBAAkB;YACxB,UAAU,EAAE,KAAK,CAAC,WAAW,EAAE;YAC/B,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ;YAChC,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,MAAM;YAC5B,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ;YAChC,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC,UAAU;YACpC,UAAU;YACV,IAAI,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC;SACrC,CAAC;IACJ,CAAC;CAAA;AAED,SAAS,gBAAgB,CAAiC,KAGzD;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAE/B,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,CACwD,CAAC;IACtE,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,iCAAiC;QACvC,WAAW;QACX,OAAO,EAAE;YACP,iBAAiB,EAAE,CAAC,IAAI,EAAE,EAAE;gBAC1B,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;SAC0C;KAC9C,CAAC;AACJ,CAAC;AAED,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGT,CAAC;AACJ,MAAM,UAAU,GAAG;IACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGJ;IACH,MAAM;IACN,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;CACd,CAAC"}

package/lib/agent/src/orchestrate/prisma/orchestratePrismaCorrect.d.ts

@@ -0,0 +1,4 @@
+import { AutoBePrisma, IAutoBePrismaValidation } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, application: AutoBePrisma.IApplication, life?: number): Promise<IAutoBePrismaValidation>;