@autobe/agent 0.9.2 → 0.10.1

package/lib/orchestrate/prisma/orchestratePrismaSchema.js.map

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

package/lib/orchestrate/prisma/transformPrismaComponentsHistories.js

@@ -61,6 +61,15 @@ const transformPrismaComponentsHistories = (state, prefix = null) => {
                 "For example:",
                 "",
                 "* `mv_shopping_daily_stats`",
+                "",
+                "## User Role Handling",
+                "",
+                "If the Requirement Analysis Report contains User Role information, **do not normalize** user roles into a single table.",
+                "Instead, create separate tables for each distinct role mentioned in the requirements.",
+                "",
+                "For example, if the requirements mention User, Admin, and Moderator roles:",
+                "",
+                "* Create separate tables: `User`, `Admin`, `Moderator` (or with prefix: `shopping_user`, `shopping_admin`, `shopping_moderator`)",
             ].join("\n"),
         },
     ];

package/lib/orchestrate/prisma/transformPrismaComponentsHistories.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformPrismaComponentsHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/prisma/transformPrismaComponentsHistories.ts"],"names":[],"mappings":";;;AACA,+BAA0B;AAKnB,MAAM,kCAAkC,GAAG,CAChD,KAAkB,EAClB,SAAwB,IAAI,EAG5B,EAAE;IACF,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI;QACxB,OAAO;YACL;gBACE,EAAE,EAAE,IAAA,SAAE,GAAE;gBACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;gBACpC,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE;oBACJ,4CAA4C;oBAC5C,+BAA+B;oBAC/B,8CAA8C;iBAC/C,CAAC,IAAI,CAAC,GAAG,CAAC;aACZ;SACF,CAAC;IACJ,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,iiGAA6C;SAClD;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,0CAA0C;gBAC1C,EAAE;gBACF,8DAA8D;gBAC9D,gDAAgD;gBAChD,EAAE;gBACF,iBAAiB;gBACjB,KAAK,CAAC,OAAO,CAAC,MAAM;gBACpB,EAAE;gBACF,gCAAgC;gBAChC,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBACnC,KAAK;gBACL,WAAW;gBACX,EAAE;gBACF,kCAAkC,MAAM,EAAE;gBAC1C,EAAE;gBACF,2FAA2F;gBAC3F,gDAAgD;gBAChD,kEAAkE;gBAClE,yHAAyH;gBACzH,EAAE;gBACF,mBAAmB;gBACnB,EAAE;gBACF,+DAA+D;gBAC/D,EAAE;gBACF,oBAAoB;gBACpB,2BAA2B;gBAC3B,EAAE;gBACF,uIAAuI;gBACvI,cAAc;gBACd,EAAE;gBACF,6BAA6B;aAC9B,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AAnEW,QAAA,kCAAkC,sCAmE7C"}
+{"version":3,"file":"transformPrismaComponentsHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/prisma/transformPrismaComponentsHistories.ts"],"names":[],"mappings":";;;AACA,+BAA0B;AAKnB,MAAM,kCAAkC,GAAG,CAChD,KAAkB,EAClB,SAAwB,IAAI,EAG5B,EAAE;IACF,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI;QACxB,OAAO;YACL;gBACE,EAAE,EAAE,IAAA,SAAE,GAAE;gBACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;gBACpC,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE;oBACJ,4CAA4C;oBAC5C,+BAA+B;oBAC/B,8CAA8C;iBAC/C,CAAC,IAAI,CAAC,GAAG,CAAC;aACZ;SACF,CAAC;IACJ,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,iiGAA6C;SAClD;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,0CAA0C;gBAC1C,EAAE;gBACF,8DAA8D;gBAC9D,gDAAgD;gBAChD,EAAE;gBACF,iBAAiB;gBACjB,KAAK,CAAC,OAAO,CAAC,MAAM;gBACpB,EAAE;gBACF,gCAAgC;gBAChC,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBACnC,KAAK;gBACL,WAAW;gBACX,EAAE;gBACF,kCAAkC,MAAM,EAAE;gBAC1C,EAAE;gBACF,2FAA2F;gBAC3F,gDAAgD;gBAChD,kEAAkE;gBAClE,yHAAyH;gBACzH,EAAE;gBACF,mBAAmB;gBACnB,EAAE;gBACF,+DAA+D;gBAC/D,EAAE;gBACF,oBAAoB;gBACpB,2BAA2B;gBAC3B,EAAE;gBACF,uIAAuI;gBACvI,cAAc;gBACd,EAAE;gBACF,6BAA6B;gBAC7B,EAAE;gBACF,uBAAuB;gBACvB,EAAE;gBACF,yHAAyH;gBACzH,uFAAuF;gBACvF,EAAE;gBACF,4EAA4E;gBAC5E,EAAE;gBACF,kIAAkI;aACnI,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AA5EW,QAAA,kCAAkC,sCA4E7C"}

package/lib/orchestrate/prisma/transformPrismaSchemaHistories.js

@@ -48,6 +48,14 @@ const transformPrismaSchemaHistories = (analyze, component) => {
                 ...component.tables.map((table) => `    - ${table}`),
                 `  - Entire tables you can reference:`,
                 ...component.entireTables.map((table) => `    - ${table}`),
+                "",
+                "## User Role Rules",
+                "",
+                "**CRITICAL**: For User Role tables (User, Admin, Moderator, etc.):",
+                "1. **Separate tables** - Each role = independent table (User, Admin, Moderator tables)",
+                "2. **No `role` field** - Never include role enum fields in any table",
+                "",
+                "You can use TPT (Table Per Type) pattern with FK relationships if needed, or completely separate tables.",
             ].join("\n"),
         },
     ];

package/lib/orchestrate/prisma/transformPrismaSchemaHistories.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformPrismaSchemaHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/prisma/transformPrismaSchemaHistories.ts"],"names":[],"mappings":";;;AAEA,+BAA0B;AAInB,MAAM,8BAA8B,GAAG,CAC5C,OAA6B,EAC7B,SAIC,EAGD,EAAE;IACF,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,8oWAA0C;SAC/C;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE;gBACJ,oCAAoC;gBACpC,wCAAwC;gBACxC,sCAAsC;gBACtC,EAAE;;aAEH,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,0CAA0C;gBAC1C,EAAE;gBACF,8DAA8D;gBAC9D,gDAAgD;gBAChD,EAAE;gBACF,iBAAiB;gBACjB,OAAO,CAAC,MAAM;gBACd,EAAE;gBACF,gCAAgC;gBAChC,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC;gBAC7B,KAAK;gBACL,EAAE;gBACF,YAAY;gBACZ,EAAE;gBACF,wBAAwB,SAAS,CAAC,QAAQ,EAAE;gBAC5C,mCAAmC;gBACnC,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC;gBACpD,sCAAsC;gBACtC,GAAG,SAAS,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC;aAC3D,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AA1DW,QAAA,8BAA8B,kCA0DzC"}
+{"version":3,"file":"transformPrismaSchemaHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/prisma/transformPrismaSchemaHistories.ts"],"names":[],"mappings":";;;AAEA,+BAA0B;AAInB,MAAM,8BAA8B,GAAG,CAC5C,OAA6B,EAC7B,SAIC,EAGD,EAAE;IACF,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,8oWAA0C;SAC/C;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE;gBACJ,oCAAoC;gBACpC,wCAAwC;gBACxC,sCAAsC;gBACtC,EAAE;;aAEH,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,0CAA0C;gBAC1C,EAAE;gBACF,8DAA8D;gBAC9D,gDAAgD;gBAChD,EAAE;gBACF,iBAAiB;gBACjB,OAAO,CAAC,MAAM;gBACd,EAAE;gBACF,gCAAgC;gBAChC,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC;gBAC7B,KAAK;gBACL,EAAE;gBACF,YAAY;gBACZ,EAAE;gBACF,wBAAwB,SAAS,CAAC,QAAQ,EAAE;gBAC5C,mCAAmC;gBACnC,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC;gBACpD,sCAAsC;gBACtC,GAAG,SAAS,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC;gBAC1D,EAAE;gBACF,oBAAoB;gBACpB,EAAE;gBACF,oEAAoE;gBACpE,wFAAwF;gBACxF,sEAAsE;gBACtE,EAAE;gBACF,0GAA0G;aAC3G,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AAlEW,QAAA,8BAA8B,kCAkEzC"}

package/lib/orchestrate/realize/orchestrateRealize.d.ts

@@ -0,0 +1,11 @@
+import { AutoBeAssistantMessageHistory, AutoBeRealizeHistory } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+export declare const orchestrateRealize: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) => (props: IAutoBeApplicationProps) => Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory>;
+export declare const FAILED: unique symbol;
+export type FAILED = typeof FAILED;
+export declare function pipe<A, B>(a: A, ab: (a: A) => Promise<B | FAILED>): Promise<B | FAILED>;
+export declare function pipe<A, B, C>(a: A, ab: (a: A) => Promise<B | FAILED>, bc: (b: B) => Promise<C | FAILED>): Promise<C | FAILED>;
+export declare function pipe<A, B, C, D>(a: A, ab: (a: A) => Promise<B | FAILED>, bc: (b: B) => Promise<C | FAILED>, cd: (c: C) => Promise<D | FAILED>): Promise<D | FAILED>;
+export declare function pipe<A, B, C, D>(a: A, ab: (a: A) => Promise<B | FAILED>, bc: (b: B) => Promise<C | FAILED>, cd: (c: C) => Promise<D | FAILED>): Promise<D | FAILED>;

package/lib/orchestrate/realize/orchestrateRealize.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAILED = exports.orchestrateRealize = void 0;
+exports.pipe = pipe;
+const uuid_1 = require("uuid");
+const orchestrateRealizeCoder_1 = require("./orchestrateRealizeCoder");
+const orchestrateRealizePlanner_1 = require("./orchestrateRealizePlanner");
+const orchestrateRealize = (ctx) => (props) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d, _e;
+    props;
+    const ops = (_a = ctx.state().interface) === null || _a === void 0 ? void 0 : _a.document.operations;
+    if (!ops) {
+        throw new Error();
+    }
+    const files = Object.assign(Object.assign({}, (_b = ctx.state().interface) === null || _b === void 0 ? void 0 : _b.files), (_c = ctx.state().test) === null || _c === void 0 ? void 0 : _c.files.reduce((acc, file) => {
+        acc[file.location] = file.content;
+        return acc;
+    }, {}));
+    const codes = yield Promise.all(ops.map((op) => __awaiter(void 0, void 0, void 0, function* () {
+        return ({
+            operation: op,
+            result: yield pipe(op, (op) => (0, orchestrateRealizePlanner_1.orchestrateRealizePlanner)(ctx, op), (p) => (0, orchestrateRealizeCoder_1.orchestrateRealizeCoder)(ctx, op, p, files)),
+        });
+    })));
+    const successes = [];
+    const failures = [];
+    for (const code of codes) {
+        if (code.result === exports.FAILED) {
+            failures.push({
+                operation: code.operation,
+                result: code.result,
+            });
+        }
+        else {
+            successes.push({
+                operation: code.operation,
+                result: code.result,
+            });
+        }
+    }
+    const now = new Date().toISOString();
+    ctx.dispatch({
+        type: "assistantMessage",
+        text: "Any codes can not be generated.",
+        created_at: now,
+    });
+    return {
+        type: "realize",
+        compiled: 1,
+        files: {},
+        completed_at: now,
+        created_at: now,
+        id: (0, uuid_1.v4)(),
+        reason: props.reason,
+        step: (_e = (_d = ctx.state().test) === null || _d === void 0 ? void 0 : _d.step) !== null && _e !== void 0 ? _e : 0,
+    };
+});
+exports.orchestrateRealize = orchestrateRealize;
+exports.FAILED = Symbol("FAILED");
+function pipe(a, ...fns) {
+    return fns.reduce((prev, fn) => {
+        return prev.then((result) => {
+            if (result === exports.FAILED)
+                return exports.FAILED;
+            return fn(result);
+        });
+    }, Promise.resolve(a));
+}
+//# sourceMappingURL=orchestrateRealize.js.map

package/lib/orchestrate/realize/orchestrateRealize.js.map

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

package/lib/orchestrate/realize/orchestrateRealizeCoder.d.ts

@@ -0,0 +1,25 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { FAILED } from "./orchestrateRealize";
+import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
+import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
+/**
+ * Generates a TypeScript function implementation based on the given plan.
+ *
+ * This function transforms the plan (function name, input/output schema,
+ * constraints, and scenarios) into a complete TypeScript function as a string.
+ * It is responsible only for producing the code logic, and does not handle
+ * imports, exports, or formatting.
+ *
+ * Import statements are handled separately and will be injected automatically.
+ * Any unused imports will be removed by tooling (e.g. eslint).
+ *
+ * Type annotations should be omitted whenever possible to favor TypeScript's
+ * type inference, unless explicit types are critical to correctness.
+ *
+ * @param ctx - AutoBE execution context
+ * @param props - Planning result describing what function to generate
+ * @returns The generated function name and TypeScript code
+ */
+export declare const orchestrateRealizeCoder: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operation: AutoBeOpenApi.IOperation, props: RealizePlannerOutput, files: Record<string, string>) => Promise<IAutoBeRealizeCoderApplication.RealizeCoderOutput | FAILED>;

package/lib/orchestrate/realize/orchestrateRealizeCoder.js

@@ -0,0 +1,326 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orchestrateRealizeCoder = void 0;
+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 getTestScenarioArtifacts_1 = require("../test/compile/getTestScenarioArtifacts");
+const orchestrateRealize_1 = require("./orchestrateRealize");
+const transformRealizeCoderHistories_1 = require("./transformRealizeCoderHistories");
+/**
+ * Generates a TypeScript function implementation based on the given plan.
+ *
+ * This function transforms the plan (function name, input/output schema,
+ * constraints, and scenarios) into a complete TypeScript function as a string.
+ * It is responsible only for producing the code logic, and does not handle
+ * imports, exports, or formatting.
+ *
+ * Import statements are handled separately and will be injected automatically.
+ * Any unused imports will be removed by tooling (e.g. eslint).
+ *
+ * Type annotations should be omitted whenever possible to favor TypeScript's
+ * type inference, unless explicit types are critical to correctness.
+ *
+ * @param ctx - AutoBE execution context
+ * @param props - Planning result describing what function to generate
+ * @returns The generated function name and TypeScript code
+ */
+const orchestrateRealizeCoder = (ctx, operation, props, files) => __awaiter(void 0, void 0, void 0, function* () {
+    const artifacts = yield (0, getTestScenarioArtifacts_1.getTestScenarioArtifacts)(ctx, {
+        endpoint: {
+            method: operation.method,
+            path: operation.path,
+        },
+        dependencies: [],
+    });
+    const pointer = {
+        value: null,
+    };
+    const controller = createApplication({
+        model: ctx.model,
+        build: (props) => {
+            pointer.value = props.result;
+        },
+    });
+    const agent = new core_1.MicroAgentica({
+        controllers: [controller],
+        model: ctx.model,
+        vendor: ctx.vendor,
+        config: Object.assign(Object.assign({}, ctx.config), { executor: {
+                describe: null,
+            } }),
+        histories: (0, transformRealizeCoderHistories_1.transformRealizeCoderHistories)(ctx.state(), props, artifacts),
+    });
+    (0, enforceToolCall_1.enforceToolCall)(agent);
+    yield agent.conversate("Write code.");
+    const tokenUsage = agent.getTokenUsage();
+    ctx.usage().record(tokenUsage, ["realize"]);
+    if (pointer.value === null) {
+        return orchestrateRealize_1.FAILED;
+    }
+    pointer.value.implementationCode = yield ctx.compiler.typescript.beautify(pointer.value.implementationCode);
+    pointer.value.implementationCode = pointer.value.implementationCode
+        .replaceAll('import { MyGlobal } from "../MyGlobal";', "")
+        .replaceAll('import typia, { tags } from "typia";', "")
+        .replaceAll('import { Prisma } from "@prisma/client";', "")
+        .replaceAll('import { jwtDecode } from "./jwtDecode"', "");
+    pointer.value.implementationCode = [
+        'import { MyGlobal } from "../MyGlobal";',
+        'import typia, { tags } from "typia";',
+        'import { Prisma } from "@prisma/client";',
+        'import { jwtDecode } from "./jwtDecode"',
+        "",
+        pointer.value.implementationCode,
+    ].join("\n");
+    files[`src/providers/${props.functionName}.ts`] =
+        pointer.value.implementationCode;
+    return Object.assign(Object.assign({}, pointer.value), { functionName: props.functionName });
+});
+exports.orchestrateRealizeCoder = orchestrateRealizeCoder;
+function createApplication(props) {
+    (0, assertSchemaModel_1.assertSchemaModel)(props.model);
+    const application = collection[props.model];
+    return {
+        protocol: "class",
+        name: "Write code",
+        application,
+        execute: {
+            programing: (next) => {
+                props.build(next);
+            },
+        },
+    };
+}
+const claude = {
+    model: "claude",
+    options: {
+        reference: true,
+        separate: null
+    },
+    functions: [
+        {
+            name: "programing",
+            parameters: {
+                description: "Current Type: {@link IAutoBeRealizeCoderApplication.IProps}",
+                type: "object",
+                properties: {
+                    result: {
+                        $ref: "#/$defs/IAutoBeRealizeCoderApplication.RealizeCoderOutput"
+                    }
+                },
+                required: [
+                    "result"
+                ],
+                additionalProperties: false,
+                $defs: {
+                    "IAutoBeRealizeCoderApplication.RealizeCoderOutput": {
+                        description: "The result of the code generation step, representing a fully generated\nTypeScript function.",
+                        type: "object",
+                        properties: {
+                            functionName: {
+                                description: "The name of the function to be generated.\n\nThis name will be used as the function's identifier and as the export\nname in the provider file.",
+                                type: "string"
+                            },
+                            implementationCode: {
+                                description: "The raw TypeScript code string implementing the function.\n\n- The implementation must be valid TypeScript code.\n- It should focus solely on the logic of the function.\n- Import statements do **not** need to be included. They will be\n  automatically inserted by the system.\n- Any unused imports will be automatically removed by eslint.\n- Type annotations (e.g. for parameters and return types) should be omitted\n  if they can be inferred.",
+                                type: "string"
+                            }
+                        },
+                        required: [
+                            "functionName",
+                            "implementationCode"
+                        ]
+                    }
+                }
+            },
+            validate: (() => { const _io0 = input => "object" === typeof input.result && null !== input.result && _io1(input.result); const _io1 = input => "string" === typeof input.functionName && "string" === typeof input.implementationCode; const _vo0 = (input, _path, _exceptionable = true) => [("object" === typeof input.result && null !== input.result || _report(_exceptionable, {
+                    path: _path + ".result",
+                    expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
+                    value: input.result
+                })) && _vo1(input.result, _path + ".result", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".result",
+                    expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
+                    value: input.result
+                })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.functionName || _report(_exceptionable, {
+                    path: _path + ".functionName",
+                    expected: "string",
+                    value: input.functionName
+                }), "string" === typeof input.implementationCode || _report(_exceptionable, {
+                    path: _path + ".implementationCode",
+                    expected: "string",
+                    value: input.implementationCode
+                })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                if (false === __is(input)) {
+                    errors = [];
+                    _report = __typia_transform__validateReport._validateReport(errors);
+                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                        path: _path + "",
+                        expected: "IAutoBeRealizeCoderApplication.IProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "IAutoBeRealizeCoderApplication.IProps",
+                        value: input
+                    }))(input, "$input", true);
+                    const success = 0 === errors.length;
+                    return success ? {
+                        success,
+                        data: input
+                    } : {
+                        success,
+                        errors,
+                        data: input
+                    };
+                }
+                return {
+                    success: true,
+                    data: input
+                };
+            }; })()
+        }
+    ]
+};
+const collection = {
+    chatgpt: {
+        model: "chatgpt",
+        options: {
+            reference: true,
+            strict: false,
+            separate: null
+        },
+        functions: [
+            {
+                name: "programing",
+                parameters: {
+                    description: "Current Type: {@link IAutoBeRealizeCoderApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        result: {
+                            $ref: "#/$defs/IAutoBeRealizeCoderApplication.RealizeCoderOutput"
+                        }
+                    },
+                    required: [
+                        "result"
+                    ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeRealizeCoderApplication.RealizeCoderOutput": {
+                            description: "The result of the code generation step, representing a fully generated\nTypeScript function.",
+                            type: "object",
+                            properties: {
+                                functionName: {
+                                    description: "The name of the function to be generated.\n\nThis name will be used as the function's identifier and as the export\nname in the provider file.",
+                                    type: "string"
+                                },
+                                implementationCode: {
+                                    description: "The raw TypeScript code string implementing the function.\n\n- The implementation must be valid TypeScript code.\n- It should focus solely on the logic of the function.\n- Import statements do **not** need to be included. They will be\n  automatically inserted by the system.\n- Any unused imports will be automatically removed by eslint.\n- Type annotations (e.g. for parameters and return types) should be omitted\n  if they can be inferred.",
+                                    type: "string"
+                                }
+                            },
+                            required: [
+                                "functionName",
+                                "implementationCode"
+                            ]
+                        }
+                    }
+                },
+                validate: (() => { const _io0 = input => "object" === typeof input.result && null !== input.result && _io1(input.result); const _io1 = input => "string" === typeof input.functionName && "string" === typeof input.implementationCode; const _vo0 = (input, _path, _exceptionable = true) => [("object" === typeof input.result && null !== input.result || _report(_exceptionable, {
+                        path: _path + ".result",
+                        expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
+                        value: input.result
+                    })) && _vo1(input.result, _path + ".result", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".result",
+                        expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
+                        value: input.result
+                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.functionName || _report(_exceptionable, {
+                        path: _path + ".functionName",
+                        expected: "string",
+                        value: input.functionName
+                    }), "string" === typeof input.implementationCode || _report(_exceptionable, {
+                        path: _path + ".implementationCode",
+                        expected: "string",
+                        value: input.implementationCode
+                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeRealizeCoderApplication.IProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeRealizeCoderApplication.IProps",
+                            value: input
+                        }))(input, "$input", true);
+                        const success = 0 === errors.length;
+                        return success ? {
+                            success,
+                            data: input
+                        } : {
+                            success,
+                            errors,
+                            data: input
+                        };
+                    }
+                    return {
+                        success: true,
+                        data: input
+                    };
+                }; })()
+            }
+        ]
+    },
+    claude,
+    llama: claude,
+    deepseek: claude,
+    "3.1": claude,
+};
+//# sourceMappingURL=orchestrateRealizeCoder.js.map

package/lib/orchestrate/realize/orchestrateRealizeCoder.js.map

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

package/lib/orchestrate/realize/orchestrateRealizePlanner.d.ts

@@ -0,0 +1,80 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export interface RealizePlannerOutput {
+    /**
+     * The name of the function to be generated.
+     *
+     * Derived from the Swagger path and method. The function name must be written
+     * in snake_case. It serves as the entry point in both code generation and
+     * test code.
+     *
+     * Once the function is generated, the function name and file name will be the
+     * same. The generated file will be located at
+     * `src/providers/${function_name}.ts`.
+     */
+    functionName: string;
+    /**
+     * Definition of path and query parameters extracted from the OpenAPI spec.
+     *
+     * Includes input values passed via URL path or query string. Used for type
+     * definitions, validation, and function signature construction.
+     */
+    parameters: AutoBeOpenApi.IParameter[];
+    /**
+     * Schema definition for the request body input.
+     *
+     * Extracted from the requestBody section of Swagger. Represents the input
+     * data passed in the body (e.g., JSON). Used for generating function
+     * arguments or DTOs.
+     */
+    inputSchema: AutoBeOpenApi.IRequestBody | null;
+    /**
+     * Schema definition for the response body.
+     *
+     * Extracted from the responses section of Swagger. Used to define the return
+     * type and expected output in test code.
+     */
+    outputSchema: AutoBeOpenApi.IResponseBody | null;
+    /**
+     * Natural language description of the function’s purpose.
+     *
+     * Extracted from the summary or description field of Swagger. Used for code
+     * documentation, test scenario generation, and conveying function intent.
+     */
+    description: string;
+    /**
+     * HTTP method information.
+     *
+     * Extracted from the Swagger operation method. Used to define the request
+     * type during code and test generation.
+     */
+    operationType: "get" | "post" | "put" | "delete" | "patch";
+    /**
+     * List of scenario descriptions for test code generation.
+     *
+     * Each scenario describes the expected behavior of the function under certain
+     * conditions. Used as a basis for TDD-style automated test generation.
+     */
+    testScenarios: string[];
+}
+/**
+ * Generates a planning result that defines what kind of function should be
+ * created, based solely on the provided Swagger (OpenAPI) operation — without
+ * using an LLM.
+ *
+ * This function analyzes the structure of the OpenAPI operation (such as the
+ * path, method, parameters, request/response schema, and descriptions) to
+ * determine the appropriate function name, input/output types, and purpose of
+ * the function.
+ *
+ * The result of this function (`RealizePlannerOutput`) will be passed to the
+ * next step in the AutoBE pipeline, which is responsible for generating the
+ * actual implementation code.
+ *
+ * @param ctx - AutoBE context including model and configuration
+ * @param operation - A single OpenAPI operation object to analyze and plan
+ * @returns A planning object containing all structural information needed to
+ *   generate the function
+ */
+export declare const orchestrateRealizePlanner: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operation: AutoBeOpenApi.IOperation) => Promise<RealizePlannerOutput>;