@autobe/agent 0.25.7 → 0.27.0

package/src/orchestrate/test/histories/transformTestScenarioHistories.ts

@@ -5,7 +5,7 @@ import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
-import { IAutoBeTestScenarioAuthorizationRole } from "../structures/IAutoBeTestScenarioAuthorizationRole";
+import { IAutoBeTestScenarioAuthorizationActor } from "../structures/IAutoBeTestScenarioAuthorizationActor";
 import { getPrerequisites } from "../utils/getPrerequisites";
 
 export const transformTestScenarioHistories = (props: {
@@ -19,17 +19,19 @@ export const transformTestScenarioHistories = (props: {
 > => {
   const authorizations: AutoBeInterfaceAuthorization[] =
     props.state.interface?.authorizations ?? [];
-  const authorizationRoles: Map<string, IAutoBeTestScenarioAuthorizationRole> =
-    new Map();
+  const authorizationActors: Map<
+    string,
+    IAutoBeTestScenarioAuthorizationActor
+  > = new Map();
 
   for (const authorization of authorizations) {
     for (const op of authorization.operations) {
       if (op.authorizationType === null) continue;
-      const value: IAutoBeTestScenarioAuthorizationRole = MapUtil.take(
-        authorizationRoles,
-        authorization.role,
+      const value: IAutoBeTestScenarioAuthorizationActor = MapUtil.take(
+        authorizationActors,
+        authorization.name,
         () => ({
-          name: authorization.role,
+          name: authorization.name,
           join: null,
           login: null,
         }),
@@ -100,9 +102,9 @@ export const transformTestScenarioHistories = (props: {
               document: props.document,
               endpoint: el,
             }),
-            authorizationRoles: Array.from(authorizationRoles.values()).filter(
-              (role) => role.name === el.authorizationRole,
-            ),
+            authorizationActors: Array.from(
+              authorizationActors.values(),
+            ).filter((actor) => actor.name === el.authorizationActor),
           })),
         )}
         \`\`\`

package/src/orchestrate/test/orchestrateTest.ts

@@ -11,8 +11,8 @@ import { ILlmSchema } from "@samchon/openapi";
 import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeFacadeApplicationProps } from "../../context/IAutoBeFacadeApplicationProps";
 import { predicateStateMessage } from "../../utils/predicateStateMessage";
+import { IAutoBeFacadeApplicationProps } from "../facade/histories/IAutoBeFacadeApplicationProps";
 import { orchestrateTestCorrect } from "./orchestrateTestCorrect";
 import { orchestrateTestScenario } from "./orchestrateTestScenario";
 import { orchestrateTestWrite } from "./orchestrateTestWrite";
@@ -101,10 +101,11 @@ export const orchestrateTest =
     return ctx.dispatch({
       type: "testComplete",
       id: v7(),
-      created_at: new Date().toISOString(),
       files: corrects.map((s) => s.file),
       compiled: compileResult,
+      aggregates: ctx.getCurrentAggregates("test"),
       step: ctx.state().interface?.step ?? 0,
       elapsed: new Date().getTime() - start.getTime(),
+      created_at: new Date().toISOString(),
     });
   };

package/src/orchestrate/test/orchestrateTestCorrect.ts

@@ -51,6 +51,7 @@ export const orchestrateTestCorrect = async <Model extends ILlmSchema.Model>(
                 correct: (next) =>
                   ({
                     type: "testCorrect",
+                    kind: "casting",
                     id: v7(),
                     created_at: new Date().toISOString(),
                     file: {
@@ -60,6 +61,7 @@ export const orchestrateTestCorrect = async <Model extends ILlmSchema.Model>(
                     },
                     result: next.failure,
                     tokenUsage: next.tokenUsage,
+                    metric: next.metric,
                     think: next.think,
                     draft: next.draft,
                     review: next.review,
@@ -150,7 +152,7 @@ const correct = async <Model extends ILlmSchema.Model>(
   const pointer: IPointer<IAutoBeTestCorrectApplication.IProps | null> = {
     value: null,
   };
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: "testCorrect",
     histories: await transformTestCorrectHistories(ctx, {
       instruction: props.instruction,
@@ -196,10 +198,12 @@ const correct = async <Model extends ILlmSchema.Model>(
 
   ctx.dispatch({
     type: "testCorrect",
+    kind: "casting",
     id: v7(),
     created_at: new Date().toISOString(),
     file: props.validate.file,
     result: props.validate.result,
+    metric,
     tokenUsage,
     step: ctx.state().analyze?.step ?? 0,
     think: pointer.value.think,

package/src/orchestrate/test/orchestrateTestCorrectInvalidRequest.ts

@@ -63,7 +63,7 @@ const correct = async <Model extends ILlmSchema.Model>(
   > = {
     value: null,
   };
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: "testCorrect",
     histories: await transformTestCorrectInvalidRequestHistories(
       null!,
@@ -83,7 +83,7 @@ const correct = async <Model extends ILlmSchema.Model>(
     message: StringUtil.trim`
       Fix the AutoBeTest.IFunction data to resolve the compilation error.
 
-      You don't need to explain me anything, but just fix or give it up 
+      You don't need to explain me anything, but just fix or give it up
       immediately without any hesitation, explanation, and questions.
     `,
   });
@@ -103,6 +103,7 @@ const correct = async <Model extends ILlmSchema.Model>(
   );
   ctx.dispatch({
     type: "testCorrect",
+    kind: "request",
     id: v7(),
     created_at: new Date().toISOString(),
     file: {
@@ -111,6 +112,7 @@ const correct = async <Model extends ILlmSchema.Model>(
       content: write.script,
     },
     result: event.result,
+    metric,
     tokenUsage,
     step: ctx.state().analyze?.step ?? 0,
     think: pointer.value.think,

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -24,7 +24,7 @@ import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformTestScenarioHistories } from "./histories/transformTestScenarioHistories";
 import { orchestrateTestScenarioReview } from "./orchestrateTestScenarioReview";
 import { IAutoBeTestScenarioApplication } from "./structures/IAutoBeTestScenarioApplication";
-import { IAutoBeTestScenarioAuthorizationRole } from "./structures/IAutoBeTestScenarioAuthorizationRole";
+import { IAutoBeTestScenarioAuthorizationActor } from "./structures/IAutoBeTestScenarioAuthorizationActor";
 
 export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
@@ -147,8 +147,8 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
     ctx.state().interface?.authorizations ?? [];
 
   try {
-    const { tokenUsage } = await ctx.conversate({
-      source: "testScenarios",
+    const { metric, tokenUsage } = await ctx.conversate({
+      source: "testScenario",
       histories: transformTestScenarioHistories({
         state: ctx.state(),
         document: props.document,
@@ -182,8 +182,9 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
       (props.progress.completed += pointer.value.length),
     );
     ctx.dispatch({
-      type: "testScenarios",
+      type: "testScenario",
       id: v7(),
+      metric,
       tokenUsage,
       scenarios: pointer.value
         .map((v) =>
@@ -257,16 +258,16 @@ function createController<Model extends ILlmSchema.Model>(props: {
     });
 
     // Authentication Correction
-    const entireRoles: Map<string, IAutoBeTestScenarioAuthorizationRole> =
+    const entireRoles: Map<string, IAutoBeTestScenarioAuthorizationActor> =
       new Map();
     for (const authorization of props.authorizations) {
       for (const op of authorization.operations) {
         if (op.authorizationType === null) continue;
-        const value: IAutoBeTestScenarioAuthorizationRole = MapUtil.take(
+        const value: IAutoBeTestScenarioAuthorizationActor = MapUtil.take(
           entireRoles,
-          authorization.role,
+          authorization.name,
           () => ({
-            name: authorization.role,
+            name: authorization.name,
             join: null,
             login: null,
           }),
@@ -283,14 +284,14 @@ function createController<Model extends ILlmSchema.Model>(props: {
         group.endpoint,
       );
       group.scenarios.forEach((scenario) => {
-        // gathere authorization roles
-        const localRoles: Map<string, IAutoBeTestScenarioAuthorizationRole> =
+        // gather authorization actors
+        const localRoles: Map<string, IAutoBeTestScenarioAuthorizationActor> =
           new Map();
         const add = (operation: AutoBeOpenApi.IOperation) => {
-          const role: string | null = operation.authorizationRole;
-          if (role === null) return;
-          MapUtil.take(localRoles, role, () => ({
-            name: role,
+          const actor: string | null = operation.authorizationActor;
+          if (actor === null) return;
+          MapUtil.take(localRoles, actor, () => ({
+            name: actor,
             join: null,
             login: null,
           }));
@@ -304,14 +305,14 @@ function createController<Model extends ILlmSchema.Model>(props: {
           add(depOperation);
         });
 
-        // Single role case - add join operation
+        // Single actor case - add join operation
         if (localRoles.size === 1) {
-          const role: IAutoBeTestScenarioAuthorizationRole = localRoles
+          const actor: IAutoBeTestScenarioAuthorizationActor = localRoles
             .values()
             .next().value!;
-          if (role.join === null) {
+          if (actor.join === null) {
             const joinOperation: AutoBeOpenApi.IOperation | null =
-              entireRoles.get(role.name)?.join ?? null;
+              entireRoles.get(actor.name)?.join ?? null;
             if (joinOperation === null) throw new Error("Unreachable code");
 
             scenario.dependencies.push({
@@ -320,16 +321,16 @@ function createController<Model extends ILlmSchema.Model>(props: {
                 path: joinOperation.path,
               },
               purpose: StringUtil.trim`
-                Essential authentication prerequisite: 
-                This join operation (${joinOperation.method} ${joinOperation.path}) must be executed before any operations requiring '${role.name}' role authorization. 
-                It establishes the necessary user account and authentication context for the '${role.name}' role, enabling subsequent API calls that depend on this specific authorization level. 
+                Essential authentication prerequisite:
+                This join operation (${joinOperation.method} ${joinOperation.path}) must be executed before any operations requiring '${actor.name}' actor authorization.
+                It establishes the necessary user account and authentication context for the '${actor.name}' actor, enabling subsequent API calls that depend on this specific authorization level.
                 Without this join operation, the main scenario endpoint and its dependencies will fail due to insufficient authentication credentials.
               `,
             });
           }
         }
 
-        // Multiple roles case - add both join and login operations
+        // Multiple actors case - add both join and login operations
         if (localRoles.size > 1) {
           for (const role of localRoles.values()) {
             if (role.join === null) {
@@ -343,11 +344,11 @@ function createController<Model extends ILlmSchema.Model>(props: {
                   method: joinOperation.method,
                 },
                 purpose: StringUtil.trim`
-                  Multi-actor authentication setup: 
-                  This join operation (${joinOperation.method} ${joinOperation.path}) is required to establish a '${role.name}' role user account in the system. 
-                  This scenario involves multiple authorization roles, requiring separate user accounts for each role to properly test cross-role interactions and authorization boundaries. 
+                  Multi-actor authentication setup:
+                  This join operation (${joinOperation.method} ${joinOperation.path}) is required to establish a '${role.name}' actor user account in the system.
+                  This scenario involves multiple authorization actors, requiring separate user accounts for each actor to properly test cross-actor interactions and authorization boundaries.
                   The join operation creates the foundational user identity that will be used throughout the test scenario for '${role.name}' specific operations.
-                  This join operation is required for the '${role.name}' role authentication.
+                  This join operation is required for the '${role.name}' actor authentication.
                 `,
               });
             }
@@ -362,11 +363,11 @@ function createController<Model extends ILlmSchema.Model>(props: {
                   method: loginOperation.method,
                 },
                 purpose: StringUtil.trim`
-                  Role switching authentication: 
-                  This login operation (${loginOperation.method} ${loginOperation.path}) enables dynamic user role switching during test execution for the '${role.name}' role. 
-                  In scenarios with multiple actors, the test agent needs to authenticate as different users to simulate real-world multi-user interactions. 
-                  This login operation ensures proper session management and authorization context switching, allowing the test to validate permissions, access controls, and business logic that span across different user roles within a single test scenario.
-                  This login operation may be required for user role swapping between multiple actors.
+                  Actor switching authentication:
+                  This login operation (${loginOperation.method} ${loginOperation.path}) enables dynamic user actor switching during test execution for the '${role.name}' actor.
+                  In scenarios with multiple actors, the test agent needs to authenticate as different users to simulate real-world multi-user interactions.
+                  This login operation ensures proper session management and authorization context switching, allowing the test to validate permissions, access controls, and business logic that span across different user actors within a single test scenario.
+                  This login operation may be required for user actor swapping between multiple actors.
                 `,
               });
             }

package/src/orchestrate/test/orchestrateTestScenarioReview.ts

@@ -42,8 +42,8 @@ async function review<Model extends ILlmSchema.Model>(
       {
         value: null,
       };
-    const { tokenUsage } = await ctx.conversate({
-      source: "testScenariosReview",
+    const { metric, tokenUsage } = await ctx.conversate({
+      source: "testScenarioReview",
       controller: createController({
         model: ctx.model,
         pointer,
@@ -68,8 +68,9 @@ async function review<Model extends ILlmSchema.Model>(
     );
 
     ctx.dispatch({
-      type: "testScenariosReview",
+      type: "testScenarioReview",
       id: v7(),
+      metric,
       tokenUsage,
       total: props.progress.total,
       completed: props.progress.completed,

package/src/orchestrate/test/orchestrateTestWrite.ts

@@ -77,7 +77,7 @@ async function process<Model extends ILlmSchema.Model>(
   const pointer: IPointer<IAutoBeTestWriteApplication.IProps | null> = {
     value: null,
   };
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: "testWrite",
     histories: await transformTestWriteHistories(ctx, {
       scenario,
@@ -122,6 +122,7 @@ async function process<Model extends ILlmSchema.Model>(
     draft: pointer.value.draft,
     review: pointer.value.revise?.review,
     final: pointer.value.revise?.final ?? undefined,
+    metric,
     tokenUsage,
     completed: ++progress.completed,
     total: progress.total,

package/src/orchestrate/test/structures/{IAutoBeTestScenarioAuthorizationRole.ts → IAutoBeTestScenarioAuthorizationActor.ts}

@@ -1,6 +1,6 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 
-export interface IAutoBeTestScenarioAuthorizationRole {
+export interface IAutoBeTestScenarioAuthorizationActor {
   name: string;
   join: AutoBeOpenApi.IOperation | null;
   login: AutoBeOpenApi.IOperation | null;

package/src/utils/TokenUsageComputer.ts

@@ -0,0 +1,35 @@
+import { IAutoBeTokenUsageJson } from "@autobe/interface";
+
+export namespace TokenUsageComputer {
+  export const plus = (
+    x: IAutoBeTokenUsageJson.IComponent,
+    y: IAutoBeTokenUsageJson.IComponent,
+  ): IAutoBeTokenUsageJson.IComponent => ({
+    total: x.total + y.total,
+    input: {
+      total: x.input.total + y.input.total,
+      cached: x.input.cached + y.input.cached,
+    },
+    output: {
+      total: x.output.total + y.output.total,
+      reasoning: x.output.reasoning + y.output.reasoning,
+      accepted_prediction:
+        x.output.accepted_prediction + y.output.accepted_prediction,
+      rejected_prediction:
+        x.output.rejected_prediction + y.output.rejected_prediction,
+    },
+  });
+
+  export const increment = (
+    x: IAutoBeTokenUsageJson.IComponent,
+    y: IAutoBeTokenUsageJson.IComponent,
+  ): void => {
+    x.total += y.total;
+    x.input.total += y.input.total;
+    x.input.cached += y.input.cached;
+    x.output.total += y.output.total;
+    x.output.reasoning += y.output.reasoning;
+    x.output.accepted_prediction += y.output.accepted_prediction;
+    x.output.rejected_prediction += y.output.rejected_prediction;
+  };
+}

package/lib/context/IAutoBeFacadeApplication.js.map

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

package/lib/context/IAutoBeFacadeApplicationProps.js.map

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

package/lib/context/IAutoBeFacadeApplicationResult.js.map

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

package/lib/factory/createAutoBeApplication.js.map

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

package/lib/orchestrate/facade/transformFacadeStateMessage.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformFacadeStateMessage = transformFacadeStateMessage;
-const utils_1 = require("@autobe/utils");
-function transformFacadeStateMessage(state) {
-    const currentState = getCurrentState(state);
-    return "<!--\nfilename: FACADE.md\n-->\n# AutoBE Main Agent System Prompt\n\nYou are the AutoBE Main Agent, an orchestrator for backend server development automation. Your role is to manage the conversation with users about their backend requirements and coordinate the execution of five specialized functional agents through function calling.\n\n## Core Responsibilities\n\n1. **Requirements Gathering**: Engage in detailed conversations with users to understand their backend server needs, asking clarifying questions about business logic, data models, API endpoints, and technical requirements.\n\n2. **Agent Orchestration**: Execute the appropriate functional agents in the correct sequence based on the development stage and user needs.\n\n3. **Progress Communication**: Keep users informed about the current development stage, what has been completed, and what steps remain.\n\n## Functional Agents Overview\n\nYou have access to five functional agents that must be executed in a specific order:\n\n1. **Analyze Agent** - Converts conversations into structured requirements specifications\n2. **Prisma Agent** - Generates database schemas and ERD documentation\n3. **Interface Agent** - Creates API interfaces with OpenAPI schemas and TypeScript code\n4. **Test Agent** - Generates comprehensive E2E test suites\n5. **Realize Agent** - Implements actual business logic for service providers\n\n## Execution Rules\n\n### 1. Sequential Dependencies\n\n- **analyze()**: Can only be called when sufficient requirements have been gathered.\n- **prisma()**: Requires successful completion of analyze()\n- **interface()**: Requires successful completion of prisma()\n- **test()**: Requires successful completion of interface()\n- **realize()**: Requires successful completion of interface()\n\n### 2. Requirements Gathering and analyze() Calling Criteria\n\n- Since users are not developers, it is okay if they do not understand technical terms like \u201Cendpoints\u201D or \u201Cdata models.\u201D  \n- Your job is to help users clearly express their intended **features** by asking many questions.  \n- Use examples and simple questions to guide them if they have trouble explaining.  \n- Break down features into smaller steps if needed to complete the planning gradually.  \n- For instance, ask questions like \u201CWhat tasks do you want to automate?\u201D, \u201CWhat roles do users have?\u201D, \u201CWhat screens or actions are involved?\u201D  \n- Even if the system requires many or complex APIs, it is not necessary to know all of them upfront. Focus on gathering core requirements step by step.  \n\n#### Conditions for Calling analyze()  \n- Call analyze() only when the user has clearly stated sufficient **features** and **requirements**, or  \n- The user explicitly delegates the planning to you by saying things like \u201CI\u2019ll leave the planning to you\u201D or \u201CPlease proceed as you see fit.\u201D  \n\n#### Pre-call Checks  \n- If requirements are insufficient for some features, do **not** call analyze() and keep asking questions until the specifications are complete.  \n- Continue asking actively and explain any technical terms in an easy-to-understand way.\n\n### 3. Requirements Gathering Phase\n\nBefore calling analyze(), ensure you have discussed:\n\n- System purpose and overall goals\n- Core features and functionalities\n- User roles and permissions\n- Main data entities and their relationships\n- Key business rules and constraints\n- API endpoints needed\n- Any specific technical requirements\n\nIf these aspects are unclear, continue the conversation to gather more details.\n\n### 4. Development Workflow\n\n1. Start by understanding the user's needs through conversation\n2. When requirements are sufficiently detailed, execute analyze()\n3. Review the analysis results with the user\n4. If approved, proceed with prisma() \u2192 interface() \u2192 test() \u2192 realize()\n5. At each stage, present results and get user confirmation before proceeding\n\n### 5. Handling Changes\n\n- If users request changes after agents have been executed, first understand the scope\n- For minor adjustments, you may re-run specific agents\n- For major changes, consider re-running analyze() to update the specification\n- Always explain the impact of changes on already generated code\n\n## Agent Instruction Guidelines\n\n### \uD83D\uDEA8 ABSOLUTE RULE #1: DOMAIN-SPECIFIC INSTRUCTION EXTRACTION WITH ZERO DISTORTION \uD83D\uDEA8\n\n**YOU ARE A DOMAIN-SPECIFIC INSTRUCTION EXTRACTOR AND COPY-PASTE MACHINE.**\n\nYour role is TWO-FOLD:\n1. **EXTRACT ONLY explicit, direct instructions for each agent's specific domain**\n   - General requirements and features are handled by analyze() - DO NOT repeat them\n   - Only extract instructions that directly tell the agent HOW to design/implement their part\n2. **COPY-PASTE the extracted instructions WITHOUT ANY MODIFICATION**\n\n### Phase-Specific Content Filtering\n\n**IMPORTANT: analyze() already processes and propagates general requirements. Each subsequent agent needs ONLY their domain-specific instructions, NOT general requirements.**\n\nEach agent should ONLY receive **direct instructions** for their specific domain:\n\n- **analyze()**: No special filtering - receives the full conversation history to analyze requirements\n- **prisma()**: ONLY direct database design instructions\n  - Explicit database schema specifications, CREATE TABLE statements\n  - Direct instructions about table structures, field definitions\n  - Specific relationship definitions (foreign keys, joins)\n  - Explicit database constraints, indexes, unique fields\n  - **NOT general requirements - analyze() handles those**\n- **interface()**: ONLY direct API/DTO design instructions  \n  - Explicit API endpoint specifications\n  - Direct request/response schema definitions\n  - Specific DTO structure instructions\n  - Explicit OpenAPI/Swagger specifications\n  - **NOT general features or user stories - only API design specifics**\n- **test()**: ONLY direct testing program instructions\n  - Explicit test scenario definitions\n  - Specific test case instructions\n  - Direct testing strategy commands\n  - Explicit validation requirements\n  - **NOT what to test (analyze provides that) - but HOW to test**\n- **realize()**: ONLY direct implementation logic instructions\n  - Explicit business logic algorithms\n  - Specific implementation patterns\n  - Direct processing logic instructions\n  - Explicit performance optimization requirements\n  - **NOT what features to implement - but HOW to implement them**\n\n### Examples of What to Extract vs What to Exclude\n\n**Example User Input:**\n\"I need a blog system where users can write posts. \nPosts table should have: id, title, content, author_id, created_at.\nAPI should have GET /posts and POST /posts endpoints.\nTest the post creation with valid and invalid data.\nWhen creating a post, validate that title is not empty.\"\n\n**What Each Agent Should Receive:**\n- **prisma()**: \"Posts table should have: id, title, content, author_id, created_at.\" \u2705\n  - NOT: \"I need a blog system where users can write posts\" \u274C (general requirement)\n- **interface()**: \"API should have GET /posts and POST /posts endpoints.\" \u2705\n  - NOT: The database schema \u274C (that's prisma's job)\n- **test()**: \"Test the post creation with valid and invalid data.\" \u2705\n  - NOT: What tables exist \u274C (analyze already knows)\n- **realize()**: \"When creating a post, validate that title is not empty.\" \u2705\n  - NOT: The API endpoint definitions \u274C (interface handles that)\n\n### Within Each Phase: ABSOLUTE COPY-PASTE RULE\n\n**Once you identify content relevant to a specific phase:**\n\n1. **COPY the user's raw text** - ctrl+C, ctrl+V, nothing else\n2. **PASTE without ANY modifications** - no editing, no summarizing, no \"improving\"\n3. **INCLUDE EVERYTHING relevant** - every line, every character, every code block\n4. **PRESERVE ORIGINAL FORMATTING** - indentation, line breaks, markdown, everything\n\n**IF YOU WRITE THINGS LIKE:**\n- \"Design database according to user specification\" \u274C WRONG\n- \"Follow the schema provided\" \u274C WRONG  \n- \"As specified in requirements\" \u274C WRONG\n- \"Create tables as shown\" \u274C WRONG\n\n**YOU MUST INSTEAD:**\n- Copy-paste the ENTIRE relevant specification \u2705\n- Include ALL relevant code blocks completely \u2705\n- Preserve ALL user comments and commands for that phase \u2705\n- Keep ALL sections, warnings, and rules related to that phase \u2705\n\nWhen calling each functional agent, you must:\n\n1. **Filter by Phase** - Extract ONLY content relevant to that specific agent\n2. **DO NOT Transform** - Copy-paste the user's exact words, do NOT rewrite\n3. **Preserve Everything Within Scope** - User's tone, emphasis, commands, code blocks for that phase\n4. **Never Summarize** - If user wrote 1000 lines about databases, prisma() gets 1000 lines\n5. **Act as a Selective Pipeline** - You filter by phase, but pass relevant content through unchanged\n\n### CRITICAL: Extract Instructions from Entire Conversation History\n\n**When preparing instructions for each agent:**\n- **SEARCH THE ENTIRE CONVERSATION HISTORY** - not just the most recent messages\n- **EXTRACT ALL RELEVANT INSTRUCTIONS** from any point in the dialogue, including early requirements, mid-conversation clarifications, and recent updates\n- **COMBINE INSTRUCTIONS CHRONOLOGICALLY** - preserve the evolution of requirements while ensuring later instructions override earlier ones when there's a conflict\n- **NEVER MISS PAST CONTEXT** - thoroughly scan all previous messages for specifications, constraints, examples, and design decisions\n- **INCLUDE FORGOTTEN DETAILS** - users may mention critical requirements early and assume you remember them throughout\n\n### CRITICAL: Preserve Original Content Without Arbitrary Summarization\n\n**When extracting instructions from user requirements:**\n- **DO clarify unclear content** when necessary for agent understanding\n- **DO NOT arbitrarily summarize or abbreviate** user requirements\n- **PRESERVE the original wording** as much as possible - stay close to the user's actual words\n- **MAINTAIN full context** - don't lose important details through oversimplification\n- **KEEP the complete narrative** - the preservation of tone and manner stems from this same principle\n- **PRESERVE ALL technical specifications verbatim** - design specs, schemas, API definitions, and code blocks MUST be included exactly as provided\n- **NEVER modify code blocks or technical specs** - pass them through unchanged, including formatting, indentation, and comments\n- **INCLUDE complete technical documentation** - if the user provides detailed specifications, architectures, or diagrams in text form, preserve them entirely\n\n### ABSOLUTE RULE: Copy-Paste Raw Content for Technical Specifications\n\n**FOR ALL TECHNICAL CONTENT (schemas, code, specifications, designs):**\n- **COPY-PASTE THE ENTIRE RAW CONTENT** - do not rewrite, summarize, or interpret\n- **INCLUDE MARKDOWN CODE BLOCKS AS-IS** - preserve ```language markers and all content within\n- **PRESERVE EXACT FORMATTING** - maintain line breaks, indentation, bullet points, numbering\n- **KEEP ALL COMMENTS AND ANNOTATIONS** - user's inline comments are part of the specification\n- **DO NOT TRANSLATE TECHNICAL TERMS** - keep CREATE TABLE, PRIMARY KEY, etc. exactly as written\n- **INCLUDE THE FULL SCHEMA/CODE** - never excerpt or abbreviate technical specifications\n\n### \uD83D\uDD34 STOP! READ THIS BEFORE CALLING ANY AGENT \uD83D\uDD34\n\n**THE INSTRUCTION PARAMETER IS NOT FOR YOUR SUMMARY. IT IS FOR PHASE-FILTERED RAW USER CONTENT.**\n\n**WHAT YOU ARE DOING WRONG:**\n```\ninstruction: \"Design the database schema according to the user's specification.\"\n```\nThis is WRONG. You are summarizing. STOP IT.\n\n**WHAT YOU MUST DO:**\n1. **FIRST: Identify content relevant to the specific agent phase**\n2. **THEN: Include that ENTIRE relevant content exactly as written by the user**\n\n**THE GOLDEN RULE FOR EACH PHASE:**\n- If the user wrote 10,000 characters about databases, prisma() gets ALL 10,000 characters\n- If the user included 50 API endpoint definitions, interface() gets ALL 50 endpoints\n- If the user wrote test scenarios with emphasis, test() gets that exact tone and wording\n- If the user described business logic, realize() gets the complete description\n\n**YOU ARE VIOLATING THIS RULE IF:**\n- Your instruction is shorter than what the user wrote for that phase\n- You removed any code blocks relevant to that phase\n- You changed any wording in the phase-specific content\n- You \"cleaned up\" the formatting of relevant content\n- You tried to \"organize\" or \"improve\" phase-specific instructions\n\n**REMEMBER:**\n- Phase filtering is MANDATORY - don't send database schemas to test()\n- Within each phase, content preservation is ABSOLUTE\n- Code blocks MUST be preserved with ``` markers\n- Every CREATE TABLE goes to prisma(), every endpoint to interface()\n- Every warning and rule SPECIFIC TO THAT PHASE must be preserved\n- You are a PHASE-SPECIFIC FILTER, then a PIPE\n\nThe goal is to pass the user's authentic voice and complete requirements to each agent, not a condensed interpretation. Technical specifications and code examples are sacred - they must flow through untouched. When in doubt, COPY MORE, not less.\n\n### IMPORTANT: Phase-Specific Instructions Only\n\n**You MUST extract ONLY the instructions relevant to each specific phase:**\n\n- **analyze()**: No special instructions needed - the agent will process the raw conversation history directly\n- **prisma()**: ONLY database design instructions (schema structure, relationships, constraints, indexing strategies)\n  - Extract and pass through VERBATIM any database schemas, CREATE TABLE statements, entity definitions\n  - Include all database-specific requirements WITHOUT interpretation\n- **interface()**: ONLY API and DTO schema instructions (endpoint patterns, request/response formats, operation specifications)\n  - Extract and pass through VERBATIM any API definitions, endpoint specifications, OpenAPI schemas\n  - Include all API-specific requirements WITHOUT modification\n- **test()**: ONLY testing strategy instructions (test scenarios, coverage priorities, edge cases to validate)\n  - Extract and pass through VERBATIM any test scenarios, test cases, validation requirements\n  - Include all testing-specific instructions WITHOUT editing\n- **realize()**: ONLY implementation instructions (business logic patterns, performance requirements, architectural decisions)\n  - Extract and pass through VERBATIM any business logic, algorithms, processing rules\n  - Include all implementation-specific requirements WITHOUT transformation\n\n**DO NOT include instructions meant for other phases. Each agent should receive ONLY its domain-specific guidance, but that guidance must be passed through UNCHANGED.**\n\n### CRITICAL: Never Fabricate User Requirements\n\n**ABSOLUTELY FORBIDDEN:**\n- **NEVER invent or create requirements the user didn't explicitly mention**\n- **NEVER expand simple requests into detailed specifications without user input**\n- **NEVER add features, functionalities, or details the user hasn't discussed**\n- **ONLY include instructions based on what the user ACTUALLY said**\n\nIf the user says \"Design an API\", do NOT create detailed specifications about platforms, features, or functionalities they never mentioned. Stick strictly to their actual words and requirements.\n\n### CRITICAL: Preserve User's Emphatic Rules and Tone\n\n**When the user provides strong directives or absolute rules, you MUST:**\n- **Preserve the exact tone and intensity** of their commands\n- **Maintain the user's original wording and emphatic language** without dilution\n- **Include all prohibitions, commands, and warnings exactly as stated**\n- **Never soften or reinterpret strong language** - if the user uses absolute terms, preserve them\n\n### Key Principle\n\n**Two-Step Process:**\n1. **Extract Domain-Specific Instructions**: Extract ONLY explicit, direct instructions for each agent's specific domain\n   - prisma(): Database design HOW-TOs only\n   - interface(): API/DTO design HOW-TOs only  \n   - test(): Testing program HOW-TOs only\n   - realize(): Implementation logic HOW-TOs only\n2. **Preserve Completely**: Pass the extracted instructions with the user's authentic voice, preserving original wording and tone WITHOUT any interpretation, transformation, or summarization\n\n**The Formula:**\n- Domain-specific instruction extraction (not general requirements) + Zero distortion (exact copy-paste) = Correct instruction passing\n\n**Remember**: analyze() handles general requirements. Other agents need ONLY their specific technical instructions.\n\n## Communication Guidelines\n\n1. **Be Transparent**: Clearly explain which agent is being executed and why\n2. **Show Progress**: Indicate completed steps and remaining work\n3. **Confirm Understanding**: Summarize requirements before executing agents\n4. **Request Approval**: Get user confirmation before moving to the next stage\n5. **Explain Results**: Briefly describe what each agent has generated\n6. **Clarify Instructions**: When calling agents, explain how you've interpreted user needs into specific instructions\n\n## Current State\n\n{% STATE %}" /* AutoBeSystemPromptConstant.FACADE */.replace("{% STATE %}", utils_1.StringUtil.trim `
-      ## Current State
-
-      The current execution status of each functional agent is shown below. 
-      Each agent can be in one of three states: "none" (never executed), 
-      "up-to-date" (successfully executed with current output), 
-      or "out-of-date" (previously executed but needs updating due to 
-      changes in earlier stages).
-
-      An agent cannot be executed if any of its prerequisite agents have 
-      a status of "none" or "out-of-date". In such cases, you must complete or 
-      update the earlier stages first. Additionally, re-executing an "up-to-date" 
-      agent will cause all subsequent agents to become "out-of-date", as they 
-      depend on the updated output.
-
-      - analyze: ${currentState.analyze}
-      - prisma: ${currentState.prisma}
-      - interface: ${currentState.interface}
-      - test: ${currentState.test}
-      - realize: ${currentState.realize}
-    `);
-}
-function getCurrentState(state) {
-    const value = (obj) => {
-        if (state.analyze === null || obj === null)
-            return "none";
-        else if (state.analyze.step === obj.step)
-            return "up-to-date";
-        else
-            return "out-of-date";
-    };
-    return {
-        analyze: state.analyze === null ? "none" : "up-to-date",
-        prisma: value(state.prisma),
-        interface: value(state.interface),
-        test: value(state.test),
-        realize: value(state.realize),
-    };
-}
-//# sourceMappingURL=transformFacadeStateMessage.js.map

package/lib/orchestrate/facade/transformFacadeStateMessage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformFacadeStateMessage.js","sourceRoot":"","sources":["../../../src/orchestrate/facade/transformFacadeStateMessage.ts"],"names":[],"mappings":";;AAKA,kEA0BC;AA/BD,yCAA2C;AAK3C,SAAgB,2BAA2B,CAAC,KAAkB;IAC5D,MAAM,YAAY,GAAkB,eAAe,CAAC,KAAK,CAAC,CAAC;IAC3D,OAAO,wliBAAkC,OAAO,CAC9C,aAAa,EACb,kBAAU,CAAC,IAAI,CAAA;;;;;;;;;;;;;;;mBAeA,YAAY,CAAC,OAAO;kBACrB,YAAY,CAAC,MAAM;qBAChB,YAAY,CAAC,SAAS;gBAC3B,YAAY,CAAC,IAAI;mBACd,YAAY,CAAC,OAAO;KAClC,CACF,CAAC;AACJ,CAAC;AAED,SAAS,eAAe,CAAC,KAAkB;IACzC,MAAM,KAAK,GAAG,CACZ,GAEQ,EACR,EAAE;QACF,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI;YAAE,OAAO,MAAM,CAAC;aACrD,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI;YAAE,OAAO,YAAY,CAAC;;YACzD,OAAO,aAAa,CAAC;IAC5B,CAAC,CAAC;IACF,OAAO;QACL,OAAO,EAAE,KAAK,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY;QACvD,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC;QAC3B,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC;QACjC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC;QACvB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC;KAC9B,CAAC;AACJ,CAAC"}

package/lib/orchestrate/interface/histories/transformInterfaceSchemasReviewHistories.d.ts

@@ -1,4 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeOpenApi } from "@autobe/interface";
-import { AutoBeState } from "../../../context/AutoBeState";
-export declare const transformInterfaceSchemasReviewHistories: (state: AutoBeState, operations: AutoBeOpenApi.IOperation[], schemaDescriptive: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;