@autobe/agent 0.18.0 → 0.19.1

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

@@ -1,70 +1,121 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeInterfaceAuthorization, AutoBeOpenApi } from "@autobe/interface";
+import { MapUtil } from "@autobe/utils";
 import { v4 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioAuthorizationRole } from "../structures/IAutoBeTestScenarioAuthorizationRole";
 
 export const transformTestScenarioHistories = (
+  state: AutoBeState,
   entire: AutoBeOpenApi.IOperation[],
   include: AutoBeOpenApi.IOperation[],
   exclude: Pick<AutoBeOpenApi.IOperation, "method" | "path">[],
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => [
-  {
-    id: v4(),
-    created_at: new Date().toISOString(),
-    type: "systemMessage",
-    text: AutoBeSystemPromptConstant.TEST_SCENARIO,
-  } satisfies IAgenticaHistoryJson.ISystemMessage,
-  {
-    id: v4(),
-    created_at: new Date().toISOString(),
-    type: "systemMessage",
-    text: [
-      "# Operations",
-      "Below are the full operations. Please refer to this.",
-      "Your role is to draft all test cases for each given Operation.",
-      "It is also permissible to write multiple test codes on a single endpoint.",
-      "However, rather than meaningless tests, business logic tests should be written and an E2E test situation should be assumed.",
-      "",
-      "Please carefully analyze each operation to identify all dependencies required for testing.",
-      "For example, if you want to test liking and then deleting a post,",
-      "you might think to test post creation, liking, and unlike operations.",
-      "However, even if not explicitly mentioned, user registration and login are essential prerequisites.",
-      "Pay close attention to IDs and related values in the API,",
-      "and ensure you identify all dependencies between endpoints.",
-      "",
-      "```json",
-      JSON.stringify(
-        entire.map((el) => ({
-          ...el,
-          specification: undefined,
-        })),
-      ),
-      "```",
-    ].join("\n"),
-  } satisfies IAgenticaHistoryJson.ISystemMessage,
-  {
-    id: v4(),
-    created_at: new Date().toISOString(),
-    type: "systemMessage",
-    text: [
-      "# Included in Test Plan",
-      include
-        .map(
-          (el) =>
-            `- ${el.method.toUpperCase()}: ${el.path} ${el.authorizationRole ? `(Role: ${el.authorizationRole})` : ""}`,
-        )
-        .join("\n"),
-      "",
-      "# Excluded from Test Plan",
-      "These are the endpoints that have already been used in test codes generated as part of a plan group.",
-      "These endpoints do not need to be tested again.",
-      "However, it is allowed to reference or depend on these endpoints when writing test codes for other purposes.",
-      exclude
-        .map((el) => `- ${el.method.toUpperCase()}: ${el.path}`)
-        .join("\n"),
-    ].join("\n"),
-  } satisfies IAgenticaHistoryJson.ISystemMessage,
-];
+> => {
+  const authorizations: AutoBeInterfaceAuthorization[] =
+    state.interface?.authorizations ?? [];
+
+  const authorizationRoles: Map<string, IAutoBeTestScenarioAuthorizationRole> =
+    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,
+        () => ({
+          name: authorization.role,
+          join: null,
+          login: null,
+        }),
+      );
+      if (op.authorizationType === "join") value.join = op;
+      else if (op.authorizationType === "login") value.login = op;
+    }
+  }
+
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.TEST_SCENARIO,
+    } satisfies IAgenticaHistoryJson.ISystemMessage,
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        "# Operations",
+        "",
+        "Below are the full operations. Please refer to this.",
+        "Your role is to draft all test cases for each given Operation.",
+        "It is also permissible to write multiple test codes on a single endpoint.",
+        "However, rather than meaningless tests, business logic tests should be written and an E2E test situation should be assumed.",
+        "",
+        "Please carefully analyze each operation to identify all dependencies required for testing.",
+        "For example, if you want to test liking and then deleting a post,",
+        "you might think to test post creation, liking, and unlike operations.",
+        "However, even if not explicitly mentioned, user registration or login are essential prerequisites.",
+        "Pay close attention to IDs and related values in the API,",
+        "and ensure you identify all dependencies between endpoints.",
+        "",
+        "```json",
+        JSON.stringify(
+          entire.map((el) => ({
+            ...el,
+            specification: undefined,
+          })),
+        ),
+        "```",
+      ].join("\n"),
+    } satisfies IAgenticaHistoryJson.ISystemMessage,
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        "# Included in Test Plan",
+        "",
+        "Below are the endpoints that have been included in the test plan.",
+        "Each endpoint shows its authentication requirements and related authentication APIs.",
+        "When testing endpoints that require authentication, ensure you include the corresponding join/login operations in your test scenario to establish proper authentication context.",
+        "",
+        include
+          .map((el, i) => {
+            const roles = Array.from(authorizationRoles.values()).filter(
+              (role) => role.name === el.authorizationRole,
+            );
+            return [
+              `## ${i + 1}. ${el.method.toUpperCase()} ${el.path}`,
+              "",
+              "Related Authentication APIs:",
+              "",
+              roles.length > 0
+                ? roles.map((role) => {
+                    return [
+                      `- ${role.join?.method.toUpperCase()}: ${role.join?.path}`,
+                      `- ${role.login?.method.toUpperCase()}: ${role.login?.path}`,
+                    ].join("\n");
+                  })
+                : "- None",
+            ];
+          })
+          .join("\n"),
+        "",
+        "# Excluded from Test Plan",
+        "",
+        "These are the endpoints that have already been used in test codes generated as part of a plan group.",
+        "These endpoints do not need to be tested again.",
+        "However, it is allowed to reference or depend on these endpoints when writing test codes for other purposes.",
+        exclude
+          .map((el) => `- ${el.method.toUpperCase()}: ${el.path}`)
+          .join("\n"),
+      ].join("\n"),
+    } satisfies IAgenticaHistoryJson.ISystemMessage,
+  ];
+};

package/src/orchestrate/test/orchestrateTest.ts

@@ -12,6 +12,7 @@ import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { predicateStateMessage } from "../../utils/predicateStateMessage";
 import { orchestrateTestCorrect } from "./orchestrateTestCorrect";
 import { orchestrateTestScenario } from "./orchestrateTestScenario";
 import { orchestrateTestWrite } from "./orchestrateTestWrite";
@@ -22,7 +23,17 @@ export const orchestrateTest =
   async (
     props: IAutoBeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeTestHistory> => {
+    // PREDICATION
     const start: Date = new Date();
+    const predicate: string | null = predicateStateMessage(ctx.state(), "test");
+    if (predicate !== null)
+      return ctx.assistantMessage({
+        type: "assistantMessage",
+        id: v4(),
+        created_at: start.toISOString(),
+        text: predicate,
+        completed_at: new Date().toISOString(),
+      });
     ctx.dispatch({
       type: "testStart",
       created_at: start.toISOString(),
@@ -30,6 +41,7 @@ export const orchestrateTest =
       step: ctx.state().analyze?.step ?? 0,
     });
 
+    // CHECK OPERATIONS
     const operations: AutoBeOpenApi.IOperation[] =
       ctx.state().interface?.document.operations ?? [];
     if (operations.length === 0)

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -1,6 +1,11 @@
 import { IAgenticaController } from "@agentica/core";
-import { AutoBeOpenApi, AutoBeTestScenario } from "@autobe/interface";
-import { AutoBeEndpointComparator } from "@autobe/utils";
+import {
+  AutoBeInterfaceAuthorization,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+  AutoBeTestScenario,
+} from "@autobe/interface";
+import { AutoBeEndpointComparator, MapUtil, StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { HashMap, IPointer, Pair } from "tstl";
 import typia from "typia";
@@ -8,9 +13,9 @@ import typia from "typia";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
-import { IProgress } from "../internal/IProgress";
 import { transformTestScenarioHistories } from "./histories/transformTestScenarioHistories";
 import { IAutoBeTestScenarioApplication } from "./structures/IAutoBeTestScenarioApplication";
+import { IAutoBeTestScenarioAuthorizationRole } from "./structures/IAutoBeTestScenarioAuthorizationRole";
 
 export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
@@ -38,6 +43,7 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
       AutoBeEndpointComparator.hashCode,
       AutoBeEndpointComparator.equals,
     );
+
   const endpointNotFound: string = [
     `You have to select one of the endpoints below`,
     "",
@@ -46,7 +52,7 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
     ...operations.map((op) => `\`${op.method}\` | \`${op.path}\``).join("\n"),
   ].join("\n");
 
-  const progress: IProgress = {
+  const progress: AutoBeProgressEventBase = {
     total: operations.length,
     completed: 0,
   };
@@ -105,18 +111,28 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
   entire: AutoBeOpenApi.IOperation[],
   include: AutoBeOpenApi.IOperation[],
   exclude: AutoBeOpenApi.IEndpoint[],
-  progress: IProgress,
+  progress: AutoBeProgressEventBase,
 ) => {
   const pointer: IPointer<IAutoBeTestScenarioApplication.IScenarioGroup[]> = {
     value: [],
   };
+
+  const authorizations: AutoBeInterfaceAuthorization[] =
+    ctx.state().interface?.authorizations ?? [];
+
   const { tokenUsage } = await ctx.conversate({
     source: "testScenarios",
-    histories: transformTestScenarioHistories(entire, include, exclude),
+    histories: transformTestScenarioHistories(
+      ctx.state(),
+      entire,
+      include,
+      exclude,
+    ),
     controller: createController({
       model: ctx.model,
       endpointNotFound,
       dict,
+      authorizations,
       build: (next) => {
         pointer.value ??= [];
         pointer.value.push(...next.scenarioGroups);
@@ -154,6 +170,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   endpointNotFound: string;
   dict: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>;
+  authorizations: AutoBeInterfaceAuthorization[];
   build: (next: IAutoBeTestScenarioApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
@@ -166,19 +183,8 @@ function createController<Model extends ILlmSchema.Model>(props: {
     if (result.success === false) return result;
 
     // merge to unique scenario groups
-    const scenarioGroups: IAutoBeTestScenarioApplication.IScenarioGroup[] = [];
-    result.data.scenarioGroups.forEach((sg) => {
-      const created = scenarioGroups.find(
-        (el) =>
-          el.endpoint.method === sg.endpoint.method &&
-          el.endpoint.path === sg.endpoint.path,
-      );
-      if (created) {
-        created.scenarios.push(...sg.scenarios);
-      } else {
-        scenarioGroups.push(sg);
-      }
-    });
+    const scenarioGroups: IAutoBeTestScenarioApplication.IScenarioGroup[] =
+      uniqueScenarioGroups(result.data.scenarioGroups);
 
     // validate endpoints
     const errors: IValidation.IError[] = [];
@@ -202,6 +208,125 @@ function createController<Model extends ILlmSchema.Model>(props: {
         });
       });
     });
+
+    // Authentication Correction
+    const entireRoles: Map<string, IAutoBeTestScenarioAuthorizationRole> =
+      new Map();
+    for (const authorization of props.authorizations) {
+      for (const op of authorization.operations) {
+        if (op.authorizationType === null) continue;
+        const value: IAutoBeTestScenarioAuthorizationRole = MapUtil.take(
+          entireRoles,
+          authorization.role,
+          () => ({
+            name: authorization.role,
+            join: null,
+            login: null,
+          }),
+        );
+        if (op.authorizationType === "join") value.join = op;
+        else if (op.authorizationType === "login") value.login = op;
+      }
+    }
+
+    scenarioGroups.forEach((group) => {
+      if (props.dict.has(group.endpoint) === false) return;
+
+      const operation: AutoBeOpenApi.IOperation = props.dict.get(
+        group.endpoint,
+      );
+      group.scenarios.forEach((scenario) => {
+        // gathere authorization roles
+        const localRoles: Map<string, IAutoBeTestScenarioAuthorizationRole> =
+          new Map();
+        const add = (operation: AutoBeOpenApi.IOperation) => {
+          const role: string | null = operation.authorizationRole;
+          if (role === null) return;
+          MapUtil.take(localRoles, role, () => ({
+            name: role,
+            join: null,
+            login: null,
+          }));
+        };
+        add(operation);
+        scenario.dependencies.forEach((d) => {
+          if (props.dict.has(d.endpoint) === false) return;
+          const depOperation: AutoBeOpenApi.IOperation = props.dict.get(
+            d.endpoint,
+          );
+          add(depOperation);
+        });
+
+        // Single role case - add join operation
+        if (localRoles.size === 1) {
+          const role: IAutoBeTestScenarioAuthorizationRole = localRoles
+            .values()
+            .next().value!;
+          if (role.join === null) {
+            const joinOperation: AutoBeOpenApi.IOperation | null =
+              entireRoles.get(role.name)?.join ?? null;
+            if (joinOperation === null) throw new Error("Unreachable code");
+
+            scenario.dependencies.push({
+              endpoint: {
+                method: joinOperation.method,
+                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. 
+                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
+        if (localRoles.size > 1) {
+          for (const role of localRoles.values()) {
+            if (role.join === null) {
+              const joinOperation: AutoBeOpenApi.IOperation | null =
+                entireRoles.get(role.name)?.join ?? null;
+              if (joinOperation === null) throw new Error("Unreachable code");
+
+              scenario.dependencies.push({
+                endpoint: {
+                  path: joinOperation.path,
+                  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. 
+                  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.
+                `,
+              });
+            }
+            if (role.login === null) {
+              const loginOperation: AutoBeOpenApi.IOperation | null =
+                entireRoles.get(role.name)?.login ?? null;
+              if (loginOperation === null) throw new Error("Unreachable code");
+
+              scenario.dependencies.push({
+                endpoint: {
+                  path: loginOperation.path,
+                  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.
+                `,
+              });
+            }
+          }
+        }
+      });
+    });
     return errors.length === 0
       ? {
           success: true,
@@ -234,6 +359,17 @@ function createController<Model extends ILlmSchema.Model>(props: {
   };
 }
 
+const uniqueScenarioGroups = (
+  groups: IAutoBeTestScenarioApplication.IScenarioGroup[],
+): IAutoBeTestScenarioApplication.IScenarioGroup[] =>
+  new HashMap(
+    groups.map((g) => new Pair(g.endpoint, g)),
+    AutoBeEndpointComparator.hashCode,
+    AutoBeEndpointComparator.equals,
+  )
+    .toJSON()
+    .map((it) => it.second);
+
 const collection = {
   chatgpt: (validate: Validator) =>
     typia.llm.application<IAutoBeTestScenarioApplication, "chatgpt">({

package/src/orchestrate/test/orchestrateTestWrite.ts

@@ -1,5 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
+  AutoBeProgressEventBase,
   AutoBeTestScenario,
   AutoBeTestWriteEvent,
   IAutoBeCompiler,
@@ -10,7 +11,6 @@ import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { IProgress } from "../internal/IProgress";
 import { completeTestCode } from "./compile/completeTestCode";
 import { getTestScenarioArtifacts } from "./compile/getTestScenarioArtifacts";
 import { transformTestWriteHistories } from "./histories/transformTestWriteHistories";
@@ -22,7 +22,7 @@ export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   scenarios: AutoBeTestScenario[],
 ): Promise<IAutoBeTestWriteResult[]> {
-  const progress: IProgress = {
+  const progress: AutoBeProgressEventBase = {
     total: scenarios.length,
     completed: 0,
   };
@@ -69,7 +69,7 @@ async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   scenario: AutoBeTestScenario,
   artifacts: IAutoBeTestScenarioArtifacts,
-  progress: IProgress,
+  progress: AutoBeProgressEventBase,
 ): Promise<AutoBeTestWriteEvent> {
   const pointer: IPointer<IAutoBeTestWriteApplication.IProps | null> = {
     value: null,

package/src/orchestrate/test/structures/IAutoBeTestCorrectApplication.ts

@@ -31,7 +31,7 @@ export namespace IAutoBeTestCorrectApplication {
      * AI analyzes the original test scenario, business requirements, and
      * intended functionality without being influenced by compilation errors.
      * This clean analysis establishes a clear understanding of what the test
-     * should accomplish, the expected business workflow, and the correct API
+     * accomplishes, the expected business workflow, and the correct API
      * integration patterns.
      *
      * This step ensures that error correction doesn't lose sight of the
@@ -70,17 +70,18 @@ export namespace IAutoBeTestCorrectApplication {
      * AI generates the first corrected version of the test code based on error
      * analysis and correction strategies. This draft addresses all identified
      * compilation errors while preserving the original business logic and test
-     * workflow. The code must be compilation-error-free and follow all
+     * workflow. The code is compilation-error-free and follows all
      * established conventions.
      *
      * The implementation incorporates lessons learned from error analysis to
      * produce properly typed, syntactically correct code that maintains the
      * intended test functionality. All type safety requirements and framework
-     * conventions must be followed in this corrected implementation.
+     * conventions are followed in this corrected implementation.
      *
      * Workflow: Error correction → TypeScript implementation → Functional
-     * preservation Critical: Must resolve all compilation errors while
-     * maintaining original test intent
+     * preservation
+     * 
+     * DO: Resolve all compilation errors while maintaining original test intent
      */
     draft: string;
 

package/src/orchestrate/test/structures/IAutoBeTestScenarioApplication.ts

@@ -63,7 +63,7 @@ export namespace IAutoBeTestScenarioApplication {
      *
      * ## Naming Convention
      *
-     * MUST use snake_case naming convention.
+     * DO: Use snake_case naming convention.
      *
      * - Must start with `test_api_` prefix (mandatory requirement)
      * - ALWAYS start with business feature, NOT action verbs

package/src/orchestrate/test/structures/IAutoBeTestScenarioAuthorizationRole.ts

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

package/src/utils/predicateStateMessage.ts

@@ -0,0 +1,107 @@
+import { StringUtil } from "@autobe/utils";
+
+import { AutoBeState } from "../context/AutoBeState";
+
+type StepName = "analyze" | "prisma" | "interface" | "test" | "realize";
+
+export const predicateStateMessage = (
+  state: AutoBeState,
+  future: StepName,
+): string | null => {
+  if (future === "analyze") return null;
+  if (future === "prisma") return predicatePrisma(state);
+
+  const futureIndex: number = STEP_ORDER.indexOf(future);
+  for (const key of STEP_ORDER.slice(0, futureIndex))
+    if (state[key] === null) return buildMissingStepsMessage(future, key);
+
+  const prevStepName: StepName = STEP_ORDER[futureIndex - 1];
+  if (state.analyze!.step !== state[prevStepName]!.step)
+    return buildOutdatedMessage(prevStepName, "analyze", state);
+  return null;
+};
+
+const buildMissingStepsMessage = (
+  current: StepName,
+  missing: StepName,
+): string => {
+  const currentIndex: number = STEP_ORDER.indexOf(current);
+  const missingIndex: number = STEP_ORDER.indexOf(missing);
+  const remainingSteps: string = STEP_ORDER.slice(
+    missingIndex,
+    currentIndex + 1,
+  )
+    .map((step, index) => `${index + 1}. ${STEP_DESCRIPTIONS[step]}`)
+    .join("\n    ");
+
+  const currentAction = ACTION_NAMES[current];
+
+  return StringUtil.trim`
+    ${STEP_DESCRIPTIONS[missing]} not completed yet.
+
+    To ${currentAction}, complete these steps:
+    
+    ${remainingSteps}
+
+    Start with step ${missingIndex + 1}.
+  `;
+};
+
+const buildOutdatedMessage = (
+  outdatedStep: StepName,
+  currentStep: StepName,
+  state: AutoBeState,
+): string => {
+  const outdatedVersion = state[outdatedStep]?.step;
+  const currentVersion = state[currentStep]?.step;
+
+  return StringUtil.trim`
+    ${STEP_NAMES[outdatedStep]} is outdated (step ${outdatedVersion}).
+    
+    Requirements are now at step ${currentVersion}.
+    
+    Please update ${outdatedStep} to match current requirements.
+  `;
+};
+
+const predicatePrisma = (state: AutoBeState): string | null => {
+  if (state.analyze !== null) return null;
+  return StringUtil.trim`
+    Requirements analysis not started.
+    
+    Discuss your project with AI to generate requirements analysis.
+    Database design will follow after requirements are ready.
+  `;
+};
+
+const STEP_DESCRIPTIONS: Record<StepName, string> = {
+  analyze: "Requirements analysis",
+  prisma: "Database design",
+  interface: "API interface design",
+  test: "E2E test creation",
+  realize: "Implementation",
+};
+
+const STEP_NAMES: Record<StepName, string> = {
+  analyze: "Requirements analysis",
+  prisma: "Database schema",
+  interface: "API interface",
+  test: "Test functions",
+  realize: "Implementation",
+};
+
+const ACTION_NAMES: Record<StepName, string> = {
+  analyze: "analyze requirements",
+  prisma: "design database",
+  interface: "design API interface",
+  test: "create tests",
+  realize: "implement the program",
+};
+
+const STEP_ORDER: StepName[] = [
+  "analyze",
+  "prisma",
+  "interface",
+  "test",
+  "realize",
+];

package/lib/agent/src/orchestrate/internal/IProgress.d.ts

@@ -1,4 +0,0 @@
-export interface IProgress {
-    total: number;
-    completed: number;
-}

package/lib/agent/src/orchestrate/internal/IProgress.js.map

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

package/lib/agent/src/orchestrate/realize/histories/transformRealizeCoderHistories.d.ts

@@ -1,7 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeRealizeAuthorization, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
-import { AutoBeState } from "../../../context/AutoBeState";
-import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
-import { IAutoBeRealizeScenario } from "../orchestrateRealizeScenario";
-import { IAutoBeRealizeCompile } from "../structures/IAutoBeRealizeCompile";
-export declare const transformRealizeCoderHistories: (state: AutoBeState, previousCodes: IAutoBeRealizeCompile.Success[], props: IAutoBeRealizeScenario, artifacts: IAutoBeTestScenarioArtifacts, previous: string | null, diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[], authorization?: AutoBeRealizeAuthorization) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;