@autobe/agent 0.0.0

package/lib/internal/createAutoBeApplication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAutoBeApplication.js","sourceRoot":"","sources":["../../src/internal/createAutoBeApplication.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,kDAA0B;AAI1B,0EAAuE;AACvE,8EAA2E;AAC3E,wEAAqE;AACrE,0EAAuE;AACvE,oEAAiE;AAE1D,MAAM,sBAAsB,GAAG,CAAiC,KAGtE,EAAqC,EAAE;IACtC,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,CACyB,CAAC;IACvC,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,QAAQ;QACd,WAAW;QACX,OAAO,EAAE;YACP,OAAO,EAAE,IAAA,uCAAkB,EAAC,KAAK,CAAC,OAAO,CAAC;YAC1C,MAAM,EAAE,IAAA,qCAAiB,EAAC,KAAK,CAAC,OAAO,CAAC;YACxC,SAAS,EAAE,IAAA,2CAAoB,EAAC,KAAK,CAAC,OAAO,CAAC;YAC9C,IAAI,EAAE,IAAA,iCAAe,EAAC,KAAK,CAAC,OAAO,CAAC;YACpC,OAAO,EAAE,IAAA,uCAAkB,EAAC,KAAK,CAAC,OAAO,CAAC;SAC3C;KACF,CAAC;AACJ,CAAC,CAAC;AAnBW,QAAA,sBAAsB,0BAmBjC;AAEF,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAC;AACrE,MAAM,UAAU,GAAG;IACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAIJ;IACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAuD;IAC7D,MAAM;IACN,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;IACb,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAoD;CAC1D,CAAC"}

package/lib/internal/createAutoBeState.d.ts

@@ -0,0 +1,3 @@
+import { AutoBeHistory } from "@autobe/interface";
+import { AutoBeState } from "../context/AutoBeState";
+export declare const createAutoBeState: (histories: AutoBeHistory[]) => AutoBeState;

package/lib/internal/createAutoBeState.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAutoBeState = void 0;
+const createAutoBeState = (histories) => {
+    var _a, _b, _c, _d, _e;
+    const reversed = histories.slice().reverse();
+    return {
+        analyze: (_a = reversed.find((h) => h.type === "analyze")) !== null && _a !== void 0 ? _a : null,
+        prisma: (_b = reversed.find((h) => h.type === "prisma")) !== null && _b !== void 0 ? _b : null,
+        interface: (_c = reversed.find((h) => h.type === "interface")) !== null && _c !== void 0 ? _c : null,
+        test: (_d = reversed.find((h) => h.type === "test")) !== null && _d !== void 0 ? _d : null,
+        realize: (_e = reversed.find((h) => h.type === "realize")) !== null && _e !== void 0 ? _e : null,
+    };
+};
+exports.createAutoBeState = createAutoBeState;
+//# sourceMappingURL=createAutoBeState.js.map

package/lib/internal/createAutoBeState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAutoBeState.js","sourceRoot":"","sources":["../../src/internal/createAutoBeState.ts"],"names":[],"mappings":";;;AAIO,MAAM,iBAAiB,GAAG,CAAC,SAA0B,EAAe,EAAE;;IAC3E,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC;IAC7C,OAAO;QACL,OAAO,EAAE,MAAA,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,mCAAI,IAAI;QAC3D,MAAM,EAAE,MAAA,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,mCAAI,IAAI;QACzD,SAAS,EAAE,MAAA,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,WAAW,CAAC,mCAAI,IAAI;QAC/D,IAAI,EAAE,MAAA,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,mCAAI,IAAI;QACrD,OAAO,EAAE,MAAA,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,mCAAI,IAAI;KAC5D,CAAC;AACJ,CAAC,CAAC;AATW,QAAA,iBAAiB,qBAS5B"}

package/lib/internal/transformAgenticaHistory.d.ts

@@ -0,0 +1,7 @@
+import { AgenticaOperation, MicroAgenticaHistory } from "@agentica/core";
+import { AutoBeHistory } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+export declare function transformAgenticaHistory<Model extends ILlmSchema.Model>(props: {
+    operations: readonly AgenticaOperation<Model>[];
+    history: AutoBeHistory;
+}): MicroAgenticaHistory<Model> | null;

package/lib/internal/transformAgenticaHistory.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformAgenticaHistory = transformAgenticaHistory;
+function transformAgenticaHistory(props) {
+    if (props.history.type === "userMessage")
+        return Object.assign(Object.assign({}, props.history), { toJSON: () => props.history });
+    else if (props.history.type === "assistantMessage")
+        return Object.assign(Object.assign({}, props.history), { toJSON: () => props.history });
+    const operation = props.operations.find((op) => op.function.name === props.history.type);
+    if (operation === undefined)
+        return null;
+    const partial = {
+        id: props.history.id,
+        type: "execute",
+        arguments: {
+            reason: props.history.reason,
+        },
+        value: {
+            success: props.history.type === "analyze" || props.history.type === "interface"
+                ? true
+                : props.history.result.type === "success",
+            description: props.history.description,
+        },
+    };
+    return Object.assign(Object.assign({}, partial), { protocol: operation.protocol, operation: operation, toJSON: () => (Object.assign(Object.assign({}, partial), { protocol: operation.protocol, operation: operation.toJSON() })) });
+}
+//# sourceMappingURL=transformAgenticaHistory.js.map

package/lib/internal/transformAgenticaHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformAgenticaHistory.js","sourceRoot":"","sources":["../../src/internal/transformAgenticaHistory.ts"],"names":[],"mappings":";;AAQA,4DA6CC;AA7CD,SAAgB,wBAAwB,CAEtC,KAGD;IACC,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,KAAK,aAAa;QACtC,uCACK,KAAK,CAAC,OAAO,KAChB,MAAM,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,OAAmC,IACvD;SACC,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,KAAK,kBAAkB;QAChD,uCACK,KAAK,CAAC,OAAO,KAChB,MAAM,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,OAAwC,IAC5D;IAEJ,MAAM,SAAS,GAAyC,KAAK,CAAC,UAAU,CAAC,IAAI,CAC3E,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,KAAK,KAAK,CAAC,OAAO,CAAC,IAAI,CAChD,CAAC;IACF,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACzC,MAAM,OAAO,GAAG;QACd,EAAE,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE;QACpB,IAAI,EAAE,SAAkB;QACxB,SAAS,EAAE;YACT,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM;SAC7B;QACD,KAAK,EAAE;YACL,OAAO,EACL,KAAK,CAAC,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,KAAK,WAAW;gBACpE,CAAC,CAAC,IAAI;gBACN,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS;YAC7C,WAAW,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW;SACvC;KACF,CAAC;IACF,uCACK,OAAO,KACV,QAAQ,EAAE,SAAS,CAAC,QAAmB,EACvC,SAAS,EAAE,SAA2C,EACtD,MAAM,EAAE,GAAG,EAAE,CAAC,iCACT,OAAO,KACV,QAAQ,EAAE,SAAS,CAAC,QAAmB,EACvC,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,IAC7B,IACF;AACJ,CAAC"}

package/lib/orchestrate/index.d.ts

@@ -0,0 +1,5 @@
+export { orchestrateAnalyze as analyze } from "./orchestrateAnalyze";
+export { orchestrateInterface as interface } from "./orchestrateInterface";
+export { orchestratePrisma as prisma } from "./orchestratePrisma";
+export { orchestrateTest as test } from "./orchestrateTest";
+export { orchestrateRealize as realize } from "./orchestrateRealize";

package/lib/orchestrate/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.realize = exports.test = exports.prisma = exports.interface = exports.analyze = void 0;
+var orchestrateAnalyze_1 = require("./orchestrateAnalyze");
+Object.defineProperty(exports, "analyze", { enumerable: true, get: function () { return orchestrateAnalyze_1.orchestrateAnalyze; } });
+var orchestrateInterface_1 = require("./orchestrateInterface");
+Object.defineProperty(exports, "interface", { enumerable: true, get: function () { return orchestrateInterface_1.orchestrateInterface; } });
+var orchestratePrisma_1 = require("./orchestratePrisma");
+Object.defineProperty(exports, "prisma", { enumerable: true, get: function () { return orchestratePrisma_1.orchestratePrisma; } });
+var orchestrateTest_1 = require("./orchestrateTest");
+Object.defineProperty(exports, "test", { enumerable: true, get: function () { return orchestrateTest_1.orchestrateTest; } });
+var orchestrateRealize_1 = require("./orchestrateRealize");
+Object.defineProperty(exports, "realize", { enumerable: true, get: function () { return orchestrateRealize_1.orchestrateRealize; } });
+//# sourceMappingURL=index.js.map

package/lib/orchestrate/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/orchestrate/index.ts"],"names":[],"mappings":";;;AAAA,2DAAqE;AAA5D,6GAAA,kBAAkB,OAAW;AACtC,+DAA2E;AAAlE,iHAAA,oBAAoB,OAAa;AAC1C,yDAAkE;AAAzD,2GAAA,iBAAiB,OAAU;AACpC,qDAA4D;AAAnD,uGAAA,eAAe,OAAQ;AAChC,2DAAqE;AAA5D,6GAAA,kBAAkB,OAAW"}

package/lib/orchestrate/interface/AutoBeInterfaceAgent.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=AutoBeInterfaceAgent.js.map

package/lib/orchestrate/interface/AutoBeInterfaceAgent.js.map

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

package/lib/orchestrate/orchestrateAnalyze.d.ts

@@ -0,0 +1,8 @@
+import { AutoBeAnalyzeHistory, AutoBeAssistantMessageHistory } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
+/**
+ * @todo Kakasoo
+ */
+export declare const orchestrateAnalyze: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) => (props: IAutoBeApplicationProps) => Promise<AutoBeAssistantMessageHistory | AutoBeAnalyzeHistory>;

package/lib/orchestrate/orchestrateAnalyze.js

@@ -0,0 +1,22 @@
+"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.orchestrateAnalyze = void 0;
+/**
+ * @todo Kakasoo
+ */
+const orchestrateAnalyze = (ctx) => (props) => __awaiter(void 0, void 0, void 0, function* () {
+    ctx;
+    props;
+    return null;
+});
+exports.orchestrateAnalyze = orchestrateAnalyze;
+//# sourceMappingURL=orchestrateAnalyze.js.map

package/lib/orchestrate/orchestrateAnalyze.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrateAnalyze.js","sourceRoot":"","sources":["../../src/orchestrate/orchestrateAnalyze.ts"],"names":[],"mappings":";;;;;;;;;;;;AASA;;GAEG;AACI,MAAM,kBAAkB,GAC7B,CAAiC,GAAyB,EAAE,EAAE,CAC9D,CACE,KAA8B,EACiC,EAAE;IACjE,GAAG,CAAC;IACJ,KAAK,CAAC;IACN,OAAO,IAAK,CAAC;AACf,CAAC,CAAA,CAAC;AARS,QAAA,kBAAkB,sBAQ3B"}

package/lib/orchestrate/orchestrateInterface.d.ts

@@ -0,0 +1,8 @@
+import { AutoBeAnalyzeHistory, AutoBeAssistantMessageHistory } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
+/**
+ * @todo Samchon
+ */
+export declare const orchestrateInterface: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) => (props: IAutoBeApplicationProps) => Promise<AutoBeAssistantMessageHistory | AutoBeAnalyzeHistory>;

package/lib/orchestrate/orchestrateInterface.js

@@ -0,0 +1,22 @@
+"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.orchestrateInterface = void 0;
+/**
+ * @todo Samchon
+ */
+const orchestrateInterface = (ctx) => (props) => __awaiter(void 0, void 0, void 0, function* () {
+    ctx;
+    props;
+    return null;
+});
+exports.orchestrateInterface = orchestrateInterface;
+//# sourceMappingURL=orchestrateInterface.js.map

package/lib/orchestrate/orchestrateInterface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrateInterface.js","sourceRoot":"","sources":["../../src/orchestrate/orchestrateInterface.ts"],"names":[],"mappings":";;;;;;;;;;;;AASA;;GAEG;AACI,MAAM,oBAAoB,GAC/B,CAAiC,GAAyB,EAAE,EAAE,CAC9D,CACE,KAA8B,EACiC,EAAE;IACjE,GAAG,CAAC;IACJ,KAAK,CAAC;IACN,OAAO,IAAK,CAAC;AACf,CAAC,CAAA,CAAC;AARS,QAAA,oBAAoB,wBAQ7B"}

package/lib/orchestrate/orchestratePrisma.d.ts

@@ -0,0 +1,8 @@
+import { AutoBeAssistantMessageHistory, AutoBePrismaHistory } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
+/**
+ * @todo Michael
+ */
+export declare const orchestratePrisma: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) => (props: IAutoBeApplicationProps) => Promise<AutoBeAssistantMessageHistory | AutoBePrismaHistory>;

package/lib/orchestrate/orchestratePrisma.js

@@ -0,0 +1,22 @@
+"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.orchestratePrisma = void 0;
+/**
+ * @todo Michael
+ */
+const orchestratePrisma = (ctx) => (props) => __awaiter(void 0, void 0, void 0, function* () {
+    ctx;
+    props;
+    return null;
+});
+exports.orchestratePrisma = orchestratePrisma;
+//# sourceMappingURL=orchestratePrisma.js.map

package/lib/orchestrate/orchestratePrisma.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestratePrisma.js","sourceRoot":"","sources":["../../src/orchestrate/orchestratePrisma.ts"],"names":[],"mappings":";;;;;;;;;;;;AASA;;GAEG;AACI,MAAM,iBAAiB,GAC5B,CAAiC,GAAyB,EAAE,EAAE,CAC9D,CACE,KAA8B,EACgC,EAAE;IAChE,GAAG,CAAC;IACJ,KAAK,CAAC;IACN,OAAO,IAAK,CAAC;AACf,CAAC,CAAA,CAAC;AARS,QAAA,iBAAiB,qBAQ1B"}

package/lib/orchestrate/orchestrateRealize.d.ts

@@ -0,0 +1,5 @@
+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>;

package/lib/orchestrate/orchestrateRealize.js

@@ -0,0 +1,19 @@
+"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.orchestrateRealize = void 0;
+const orchestrateRealize = (ctx) => (props) => __awaiter(void 0, void 0, void 0, function* () {
+    ctx;
+    props;
+    return null;
+});
+exports.orchestrateRealize = orchestrateRealize;
+//# sourceMappingURL=orchestrateRealize.js.map

package/lib/orchestrate/orchestrateRealize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrateRealize.js","sourceRoot":"","sources":["../../src/orchestrate/orchestrateRealize.ts"],"names":[],"mappings":";;;;;;;;;;;;AASO,MAAM,kBAAkB,GAC7B,CAAiC,GAAyB,EAAE,EAAE,CAC9D,CACE,KAA8B,EACiC,EAAE;IACjE,GAAG,CAAC;IACJ,KAAK,CAAC;IACN,OAAO,IAAK,CAAC;AACf,CAAC,CAAA,CAAC;AARS,QAAA,kBAAkB,sBAQ3B"}

package/lib/orchestrate/orchestrateTest.d.ts

@@ -0,0 +1,5 @@
+import { AutoBeAssistantMessageHistory, AutoBeTestHistory } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
+export declare const orchestrateTest: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) => (props: IAutoBeApplicationProps) => Promise<AutoBeAssistantMessageHistory | AutoBeTestHistory>;

package/lib/orchestrate/orchestrateTest.js

@@ -0,0 +1,19 @@
+"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.orchestrateTest = void 0;
+const orchestrateTest = (ctx) => (props) => __awaiter(void 0, void 0, void 0, function* () {
+    ctx;
+    props;
+    return null;
+});
+exports.orchestrateTest = orchestrateTest;
+//# sourceMappingURL=orchestrateTest.js.map

package/lib/orchestrate/orchestrateTest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrateTest.js","sourceRoot":"","sources":["../../src/orchestrate/orchestrateTest.ts"],"names":[],"mappings":";;;;;;;;;;;;AASO,MAAM,eAAe,GAC1B,CAAiC,GAAyB,EAAE,EAAE,CAC9D,CACE,KAA8B,EAC8B,EAAE;IAC9D,GAAG,CAAC;IACJ,KAAK,CAAC;IACN,OAAO,IAAK,CAAC;AACf,CAAC,CAAA,CAAC;AARS,QAAA,eAAe,mBAQxB"}

package/lib/structures/IAutoBeConfig.d.ts

@@ -0,0 +1,24 @@
+export interface IAutoBeConfig {
+    /**
+     * Locale of the A.I. chatbot.
+     *
+     * If you configure this property, the A.I. chatbot will conversate with
+     * the given locale. You can get the locale value by
+     *
+     * - Browser: `navigator.language`
+     * - NodeJS: `process.env.LANG.split(".")[0]`
+     *
+     * @default your_locale
+     */
+    locale?: string;
+    /**
+     * Timezone of the A.I. chatbot.
+     *
+     * If you configure this property, the A.I. chatbot will consider the
+     * given timezone. You can get the timezone value by
+     * `Intl.DateTimeFormat().resolvedOptions().timeZone`.
+     *
+     * @default your_timezone
+     */
+    timezone?: string;
+}

package/lib/structures/IAutoBeConfig.js

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

package/lib/structures/IAutoBeConfig.js.map

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

package/lib/structures/IAutoBeProps.d.ts

@@ -0,0 +1,11 @@
+import { AutoBeHistory, IAutoBeCompiler } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { IAutoBeConfig } from "./IAutoBeConfig";
+import { IAutoBeVendor } from "./IAutoBeVendor";
+export interface IAutoBeProps<Model extends ILlmSchema.Model> {
+    model: Model;
+    vendor: IAutoBeVendor;
+    compiler: IAutoBeCompiler;
+    histories?: AutoBeHistory[] | undefined;
+    config?: IAutoBeConfig | undefined;
+}

package/lib/structures/IAutoBeProps.js

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

package/lib/structures/IAutoBeProps.js.map

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

package/lib/structures/IAutoBeVendor.d.ts

@@ -0,0 +1,2 @@
+import { IAgenticaVendor } from "@agentica/core";
+export type IAutoBeVendor = IAgenticaVendor;

package/lib/structures/IAutoBeVendor.js

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

package/lib/structures/IAutoBeVendor.js.map

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

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@autobe/agent",
+  "version": "0.0.0",
+  "description": "AI backend server code generator",
+  "main": "lib/index.js",
+  "author": "Wrtn Technologies",
+  "license": "MIT",
+  "files": [
+    "lib",
+    "src",
+    "package.json",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@agentica/core": "^0.25.0",
+    "@samchon/openapi": "^4.3.0",
+    "openai": "^4.80.0",
+    "typia": "^9.3.0",
+    "@autobe/interface": "^0.0.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.40.1",
+    "ts-patch": "^3.3.0",
+    "typescript": "~5.8.3"
+  },
+  "keywords": [
+    "ai",
+    "api",
+    "api-design",
+    "auto-generation",
+    "autobe",
+    "automation",
+    "backend",
+    "backend-development",
+    "code-generation",
+    "documentation",
+    "e2e-testing",
+    "erd",
+    "nestjs",
+    "openapi",
+    "orm",
+    "postgres",
+    "postgresql",
+    "prisma",
+    "requirements-analysis",
+    "rest",
+    "server",
+    "spiral-model",
+    "swagger",
+    "testing",
+    "typescript",
+    "vibe-coding",
+    "waterfall"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rimraf lib && rollup -c && tsc",
+    "dev": "rimraf lib && tsc --watch"
+  },
+  "typings": "lib/index.d.ts"
+}

package/src/AutoBeAgent.ts

@@ -0,0 +1,101 @@
+import { MicroAgentica } from "@agentica/core";
+import { AutoBeHistory, AutoBeUserMessageContent } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "./context/AutoBeContext";
+import { AutoBeState } from "./context/AutoBeState";
+import { AutoBeTokenUsage } from "./context/AutoBeTokenUsage";
+import { createAutoBeController } from "./internal/createAutoBeApplication";
+import { createAutoBeState } from "./internal/createAutoBeState";
+import { transformAgenticaHistory } from "./internal/transformAgenticaHistory";
+import { IAutoBeProps } from "./structures/IAutoBeProps";
+
+export class AutoBeAgent<Model extends ILlmSchema.Model> {
+  private readonly agentica_: MicroAgentica<Model>;
+  private readonly histories_: AutoBeHistory[];
+  private readonly context_: AutoBeContext<Model>;
+  private readonly state_: AutoBeState;
+
+  /* -----------------------------------------------------------
+    CONSTRUCTOR
+  ----------------------------------------------------------- */
+  /**
+   * Initializer constructor.
+   *
+   * @param props Properties to construct the agent
+   */
+  public constructor(private readonly props: IAutoBeProps<Model>) {
+    this.histories_ = props.histories?.slice() ?? [];
+    this.state_ = createAutoBeState(this.histories_);
+    this.context_ = {
+      model: props.model,
+      vendor: props.vendor,
+      compiler: props.compiler,
+      histories: this.histories_,
+      usage: () => this.agentica_.getTokenUsage(),
+      state: () => this.state_,
+    };
+
+    this.agentica_ = new MicroAgentica({
+      model: props.model,
+      vendor: props.vendor,
+      config: {
+        ...(props.config ?? {}),
+        executor: {
+          describe: null,
+        },
+      },
+      controllers: [
+        createAutoBeController({
+          model: props.model,
+          context: this.context_,
+        }),
+      ],
+    });
+    this.agentica_.getHistories().push(
+      ...this.histories_
+        .map((history) =>
+          transformAgenticaHistory({
+            operations: this.agentica_.getOperations(),
+            history,
+          }),
+        )
+        .filter((h) => h !== null),
+    );
+  }
+
+  /**
+   * @internal
+   */
+  public clone(): AutoBeAgent<Model> {
+    return new AutoBeAgent<Model>({
+      ...this.props,
+      histories: this.histories_.slice(),
+    });
+  }
+
+  /* -----------------------------------------------------------
+    ACCESSORS
+  ----------------------------------------------------------- */
+  public async conversate(
+    content: string | AutoBeUserMessageContent | AutoBeUserMessageContent[],
+  ): Promise<AutoBeHistory[]> {
+    content;
+    return [];
+  }
+
+  public getHistories(): AutoBeHistory[] {
+    return this.histories_;
+  }
+
+  public getTokenUsage(): AutoBeTokenUsage {
+    return this.agentica_.getTokenUsage();
+  }
+
+  /**
+   * @internal
+   */
+  public getContext(): AutoBeContext<Model> {
+    return this.context_;
+  }
+}

package/src/context/AutoBeContext.ts

@@ -0,0 +1,15 @@
+import { AutoBeHistory, IAutoBeCompiler } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { IAutoBeVendor } from "../structures/IAutoBeVendor";
+import { AutoBeState } from "./AutoBeState";
+import { AutoBeTokenUsage } from "./AutoBeTokenUsage";
+
+export interface AutoBeContext<Model extends ILlmSchema.Model> {
+  model: Model;
+  vendor: IAutoBeVendor;
+  compiler: IAutoBeCompiler;
+  histories: AutoBeHistory[];
+  usage: () => AutoBeTokenUsage;
+  state: () => AutoBeState;
+}

package/src/context/AutoBeState.ts

@@ -0,0 +1,15 @@
+import {
+  AutoBeAnalyzeHistory,
+  AutoBeInterfaceHistory,
+  AutoBePrismaHistory,
+  AutoBeRealizeHistory,
+  AutoBeTestHistory,
+} from "@autobe/interface";
+
+export interface AutoBeState {
+  analyze: AutoBeAnalyzeHistory | null;
+  prisma: AutoBePrismaHistory | null;
+  interface: AutoBeInterfaceHistory | null;
+  test: AutoBeTestHistory | null;
+  realize: AutoBeRealizeHistory | null;
+}

package/src/context/AutoBeTokenUsage.ts

@@ -0,0 +1,3 @@
+import { AgenticaTokenUsage } from "@agentica/core";
+
+export import AutoBeTokenUsage = AgenticaTokenUsage;

package/src/context/IAutoBeApplication.ts

@@ -0,0 +1,72 @@
+import { IAutoBeApplicationProps } from "./IAutoBeApplicationProps";
+import { IAutoBeApplicationResult } from "./IAutoBeApplicationResult";
+
+/**
+ * Application for AutoBE function calling.
+ *
+ * @author Samchon
+ */
+export interface IAutoBeApplication {
+  /**
+   * Run Analyze Agent.
+   *
+   * Analyze agent analyzes requirements and creates specification
+   * documents.
+   *
+   * The Analyze agent serves as the foundation of the entire development
+   * process. It not only captures initial requirements but also
+   * continuously refines understanding through iterative conversation
+   * with users. When requirements are ambiguous or incomplete, it
+   * proactively formulates targeted questions to elicit necessary
+   * information before proceeding with development.
+   *
+   * Additionally, once other agents have generated code, the Analyze
+   * agent can interpret change requests in the context of existing
+   * implementations, assessing the impact and feasibility of modifications
+   * while maintaining system integrity. This comprehensive approach
+   * ensures that all subsequent development stages work from a clear,
+   * complete, and consistent specification.
+   */
+  analyze(props: IAutoBeApplicationProps): Promise<IAutoBeApplicationResult>;
+
+  /**
+   * Run prisma agent.
+   *
+   * Prisma agent analyzes requirements specifications to generate
+   * database schemas in Prisma format.
+   *
+   * The Prisma agent references the requirements specification document
+   * created by the {@link analyze} function to craft the `prisma.schema`
+   * file. For each entity and attribute in the database schema, it
+   * provides comprehensive documentation including the rationale behind
+   * its creation, its purpose, and conceptual explanations. The agent
+   * employs normalization techniques to ensure high-quality database
+   * design.
+   *
+   * Once the DB schema file is written, the Prisma agent compiles it using
+   * the built-in Prisma compiler. If compilation errors occur, these are
+   * fed back to the AI agent, enabling a self-correction process through
+   * compiler feedback. After successful compilation, this schema file is
+   * then subjected to a quality assurance process through an internal
+   * review agent that verifies and refines the schema.
+   *
+   * Note that, never use this function without calling the
+   * {@link analyze} function at least once.
+   */
+  prisma(props: IAutoBeApplicationProps): Promise<IAutoBeApplicationResult>;
+
+  /**
+   * Run interface agent.
+   */
+  interface(props: IAutoBeApplicationProps): Promise<IAutoBeApplicationResult>;
+
+  /**
+   * Run test program agent.
+   */
+  test(props: IAutoBeApplicationProps): Promise<IAutoBeApplicationResult>;
+
+  /**
+   * Run realize agent.
+   */
+  realize(props: IAutoBeApplicationProps): Promise<IAutoBeApplicationResult>;
+}