@autobe/agent 0.24.0 → 0.24.2

package/src/factory/getAutoBeGenerated.ts

@@ -104,6 +104,9 @@ export async function getAutoBeGenerated(
         document: state.interface!.document,
         authorizations: state.realize.authorizations,
         functions: state.realize.functions,
+        options: {
+          dbms: options?.dbms ?? "postgres",
+        },
       }),
     );
   if (options?.stage === "test") return ret;

package/src/factory/getAutoBeRealizeGenerated.ts

@@ -3,6 +3,7 @@ import {
   AutoBeRealizeAuthorization,
   AutoBeRealizeFunction,
   IAutoBeCompiler,
+  IAutoBeGetFilesOptions,
 } from "@autobe/interface";
 
 export const getAutoBeRealizeGenerated = async (props: {
@@ -10,6 +11,7 @@ export const getAutoBeRealizeGenerated = async (props: {
   document: AutoBeOpenApi.IDocument;
   authorizations: AutoBeRealizeAuthorization[];
   functions: AutoBeRealizeFunction[];
+  options: IAutoBeGetFilesOptions;
 }): Promise<Record<string, string>> => ({
   ...Object.fromEntries(props.functions.map((f) => [f.location, f.content])),
   ...Object.fromEntries(
@@ -21,7 +23,7 @@ export const getAutoBeRealizeGenerated = async (props: {
       ])
       .flat(),
   ),
-  ...(await props.compiler.realize.getTemplate()),
+  ...(await props.compiler.realize.getTemplate(props.options)),
   ...(await props.compiler.realize.controller({
     document: props.document,
     functions: props.functions,

package/src/factory/getCriticalCompiler.ts

@@ -41,7 +41,8 @@ export const getCriticalCompiler = (
     realize: {
       controller: (props) => lock(() => compiler.realize.controller(props)),
       test: (props) => lock(() => compiler.realize.test(props)),
-      getTemplate: () => lock(() => compiler.realize.getTemplate()),
+      getTemplate: (options) =>
+        lock(() => compiler.realize.getTemplate(options)),
     },
   };
 };

package/src/orchestrate/interface/utils/JsonSchemaValidator.ts

@@ -25,22 +25,82 @@ export namespace JsonSchemaValidator {
     path: string;
     key: string;
   }): void => {
-    const variable: boolean = props.key.split(".").every(Escaper.variable);
-    if (variable === false)
+    const elements: string[] = props.key.split(".");
+    if (elements.every(Escaper.variable) === false)
       props.errors.push({
         path: `${props.path}[${JSON.stringify(props.key)}]`,
         expected: "Valid variable name",
         value: props.key,
         description: StringUtil.trim`
-            JSON schema type name must be a valid variable name.
+          JSON schema type name must be a valid variable name.
 
-            Even though JSON schema type name allows dot(.) character, but
-            each segment separated by dot(.) must be a valid variable name.
+          Even though JSON schema type name allows dot(.) character, but
+          each segment separated by dot(.) must be a valid variable name.
 
-            Current key name ${JSON.stringify(props.key)} is not valid. Change
-            it to a valid variable name at the next time.
-          `,
+          Current key name ${JSON.stringify(props.key)} is not valid. Change
+          it to a valid variable name at the next time.
+        `,
       });
+    if (props.key === "IPageIRequest")
+      props.errors.push({
+        path: `${props.path}[${JSON.stringify(props.key)}]`,
+        expected: `"IPageIRequest" is a mistake. Use "IPage.IRequest" instead.`,
+        value: props.key,
+        description: StringUtil.trim`
+          You've taken a mistake that defines "IPageIRequest" as a type name.
+          However, as you've intended to define a pagination request type, 
+          the correct type name is "IPage.IRequest" instead of "IPageIRequest".
+
+          Change it to "IPage.IRequest" at the next time.
+        `,
+      });
+    else if (
+      props.key.startsWith("IPage") &&
+      props.key.startsWith("IPageI") === false
+    ) {
+      const expected: string = `IPage${props.key
+        .substring(5)
+        .split(".")
+        .map((s) => (s.startsWith("I") ? s : `I${s}`))
+        .join(".")}`;
+      props.errors.push({
+        path: `${props.path}[${JSON.stringify(props.key)}]`,
+        expected: `Interface name starting with 'I' even after 'IPage': ${JSON.stringify(expected)}`,
+        value: props.key,
+        description: StringUtil.trim`
+          JSON schema type name must be an interface name starting with 'I'.
+          Even though JSON schema type name allows dot(.) character, but
+          each segment separated by dot(.) must be an interface name starting
+          with 'I'.
+
+          Even in the case of pagination response, after 'IPage' prefix,
+          the remaining part must be an interface name starting with 'I'.
+          
+          Current key name ${JSON.stringify(props.key)} is not valid. Change
+          it to a valid interface name to be  ${JSON.stringify(expected)},
+          or change it to another valid interface name at the next time.
+        `,
+      });
+    } else if (elements.some((s) => s.startsWith("I") === false) === true) {
+      const expected: string = elements
+        .map((s) => (s.startsWith("I") ? s : `I${s}`))
+        .join(".");
+      props.errors.push({
+        path: `${props.path}[${JSON.stringify(props.key)}]`,
+        expected: `Interface name starting with 'I': ${JSON.stringify(expected)}`,
+        value: props.key,
+        description: StringUtil.trim`
+          JSON schema type name must be an interface name starting with 'I'.
+          Even though JSON schema type name allows dot(.) character, but
+          each segment separated by dot(.) must be an interface name starting
+          with 'I'.
+
+          Current key name ${JSON.stringify(props.key)} is not valid. Change
+          it to a valid interface name to be ${JSON.stringify(expected)}, 
+          or change it to another valid interface name at the next time.
+        `,
+      });
+    }
   };
 
   const authorization = (props: IProps): void => {

package/src/orchestrate/interface/utils/OperationValidator.ts

@@ -48,12 +48,13 @@ export namespace OperationValidator {
           path: `${props.path}[${i}].requestBody.typeName`,
           key: op.requestBody.typeName,
         });
-      if (op.responseBody !== null)
+      if (op.responseBody !== null) {
         JsonSchemaValidator.validateKey({
           errors: props.errors,
           path: `${props.path}[${i}].responseBody.typeName`,
           key: op.responseBody.typeName,
         });
+      }
     });
 
     // validate duplicated endpoints

package/src/orchestrate/realize/internal/compileRealizeFiles.ts

@@ -23,7 +23,9 @@ export async function compileRealizeFiles<Model extends ILlmSchema.Model>(
   );
   const compiler: IAutoBeCompiler = await ctx.compiler();
   const templateFiles: Record<string, string> =
-    await compiler.realize.getTemplate();
+    await compiler.realize.getTemplate({
+      dbms: "sqlite",
+    });
   const nodeModules: Record<string, string> =
     prisma?.type === "success" ? prisma.nodeModules : {};
 

package/src/orchestrate/realize/orchestRateRealizeCorrectCasting.ts

@@ -166,7 +166,10 @@ const correct = async <Model extends ILlmSchema.Model>(
 
   const newValidate: AutoBeRealizeValidateEvent = await compileRealizeFiles(
     ctx,
-    { authorizations, functions: converted.map((c) => c.func) },
+    {
+      authorizations,
+      functions: converted.map((c) => c.func),
+    },
   );
 
   if (newValidate.result.type === "success") {

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -21,7 +21,6 @@ import { orchestrateRealizeAuthorization } from "./orchestrateRealizeAuthorizati
 import { orchestrateRealizeCorrect } from "./orchestrateRealizeCorrect";
 import { orchestrateRealizeCorrectDate } from "./orchestrateRealizeCorrectDate";
 import { orchestrateRealizeWrite } from "./orchestrateRealizeWrite";
-import { IAutoBeRealizeFunctionFailure } from "./structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 import { generateRealizeScenario } from "./utils/generateRealizeScenario";
 
@@ -70,22 +69,31 @@ export const orchestrateRealize =
       total: scenarios.length,
       completed: 0,
     };
-    const writeEvents: AutoBeRealizeWriteEvent[] = await executeCachedBatch(
-      scenarios.map((scenario) => async (promptCacheKey) => {
-        const code = await orchestrateRealizeWrite(ctx, {
-          totalAuthorizations: authorizations,
-          authorization: scenario.decoratorEvent ?? null,
-          scenario,
-          progress: writeProgress,
-          promptCacheKey,
-        });
-        return code;
-      }),
-    );
+    const writeEvents: (AutoBeRealizeWriteEvent | null)[] =
+      await executeCachedBatch(
+        scenarios.map((scenario) => async (promptCacheKey) => {
+          const props = {
+            totalAuthorizations: authorizations,
+            authorization: scenario.decoratorEvent ?? null,
+            scenario,
+            progress: writeProgress,
+            promptCacheKey,
+          };
+
+          const code: AutoBeRealizeWriteEvent | null =
+            await orchestrateRealizeWrite(ctx, props).catch(() => {
+              return orchestrateRealizeWrite(ctx, props).catch(() => null);
+            });
+
+          return code;
+        }),
+      );
 
     const functions: AutoBeRealizeFunction[] = Object.entries(
       Object.fromEntries(
-        writeEvents.map((event) => [event.location, event.content]),
+        writeEvents
+          .filter((w) => w !== null)
+          .map((event) => [event.location, event.content]),
       ),
     ).map(([location, content]) => {
       const scenario = scenarios.find((el) => el.location === location)!;
@@ -100,38 +108,37 @@ export const orchestrateRealize =
       };
     });
 
-    const reviewProgress = {
+    const reviewProgress: AutoBeProgressEventBase = {
       total: writeEvents.length,
       completed: writeEvents.length,
     };
 
-    const converted: AutoBeRealizeFunction[] =
+    console.log("casting", reviewProgress);
+    const totalCorrected: AutoBeRealizeFunction[] =
       await orchestrateRealizeCorrectCasting(
         ctx,
         authorizations,
         functions,
         reviewProgress,
-        parseInt((ctx.retry / 2).toString()),
-      );
-
-    const correctedDate: AutoBeRealizeFunction[] =
-      await orchestrateRealizeCorrectDate(
-        ctx,
-        authorizations,
-        converted,
-        reviewProgress,
-        parseInt((ctx.retry / 2).toString()),
-      );
-
-    const totalCorrected: AutoBeRealizeFunction[] =
-      await orchestrateRealizeCorrect(
-        ctx,
-        scenarios,
-        authorizations,
-        correctedDate,
-        [] satisfies IAutoBeRealizeFunctionFailure[],
-        reviewProgress,
-      );
+      ).then(async (res) => {
+        console.log("date", reviewProgress);
+        return orchestrateRealizeCorrectDate(
+          ctx,
+          authorizations,
+          res,
+          reviewProgress,
+        ).then(async (res) => {
+          console.log("correct", reviewProgress);
+          return orchestrateRealizeCorrect(
+            ctx,
+            scenarios,
+            authorizations,
+            res,
+            [],
+            reviewProgress,
+          );
+        });
+      });
 
     const compiler: IAutoBeCompiler = await ctx.compiler();
     const controllers: Record<string, string> =

package/src/orchestrate/realize/orchestrateRealizeAuthorization.ts

@@ -41,7 +41,11 @@ export async function orchestrateRealizeAuthorization<
     total: roles.length,
     completed: 0,
   };
-  const templateFiles = await (await ctx.compiler()).realize.getTemplate();
+  const templateFiles = await (
+    await ctx.compiler()
+  ).realize.getTemplate({
+    dbms: "sqlite",
+  });
   const authorizations: AutoBeRealizeAuthorization[] = await executeCachedBatch(
     roles.map(
       (role) => (promptCacheKey) =>

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -35,7 +35,6 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
     authorizations,
     functions,
   });
-
   if (event.result.type !== "failure") return functions;
   else if (life < 0) return functions;
 
@@ -130,16 +129,22 @@ async function correct<Model extends ILlmSchema.Model>(
 
       if (RealizeFunctionFailures.length && scenario) {
         try {
-          const correctEvent = await step(ctx, {
-            totalAuthorizations: authorizations,
-            authorization: scenario.decoratorEvent ?? null,
-            scenario,
-            function: func,
-            failures: RealizeFunctionFailures,
-            progress: progress,
-          });
-
-          return { ...func, content: correctEvent.content };
+          const correctEvent: AutoBeRealizeCorrectEvent | null = await step(
+            ctx,
+            {
+              totalAuthorizations: authorizations,
+              authorization: scenario.decoratorEvent ?? null,
+              scenario,
+              function: func,
+              failures: RealizeFunctionFailures,
+              progress: progress,
+            },
+          );
+
+          return {
+            ...func,
+            content: correctEvent === null ? "" : correctEvent.content,
+          };
         } catch (err) {
           return func;
         }
@@ -162,7 +167,7 @@ async function step<Model extends ILlmSchema.Model>(
     failures: IAutoBeRealizeFunctionFailure[];
     progress: AutoBeProgressEventBase;
   },
-): Promise<AutoBeRealizeCorrectEvent> {
+): Promise<AutoBeRealizeCorrectEvent | null> {
   const pointer: IPointer<IAutoBeRealizeCorrectApplication.IProps | null> = {
     value: null,
   };
@@ -193,8 +198,9 @@ async function step<Model extends ILlmSchema.Model>(
     `,
   });
 
-  if (pointer.value === null)
-    throw new Error("Failed to correct implementation code.");
+  if (pointer.value === null) {
+    return null;
+  }
 
   pointer.value.revise.final = await replaceImportStatements(ctx, {
     operation: props.scenario.operation,

package/src/orchestrate/realize/utils/getRealizeWriteImportStatements.ts

@@ -19,6 +19,7 @@ export function getRealizeWriteImportStatements(
     'import { Prisma } from "@prisma/client";',
     'import { v4 } from "uuid";',
     'import { toISOStringSafe } from "../util/toISOStringSafe"',
+    'import { HttpException } from "@nestjs/common";',
     ...typeReferences.map(
       (ref) =>
         `import { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,

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

@@ -0,0 +1,156 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { ILlmSchema } from "@samchon/openapi";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeTestScenarioApplication } from "../structures/IAutoBeTestScenarioApplication";
+import { getReferenceIds } from "../utils/getReferenceIds";
+
+export function transformTestScenarioReviewHistories<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  groups: IAutoBeTestScenarioApplication.IScenarioGroup[],
+): Array<
+  IAgenticaHistoryJson.ISystemMessage | IAgenticaHistoryJson.IAssistantMessage
+> {
+  interface IRelationship {
+    endpoint: AutoBeOpenApi.IEndpoint;
+    ids: string[];
+  }
+
+  const document: AutoBeOpenApi.IDocument | undefined =
+    ctx.state().interface?.document;
+
+  if (document === undefined) {
+    throw new Error(
+      "Cannot review test scenarios because there are no operations.",
+    );
+  }
+
+  const relationships: IRelationship[] = document.operations
+    .map((o) => ({
+      endpoint: {
+        method: o.method,
+        path: o.path,
+      },
+      ids: getReferenceIds({
+        document,
+        operation: o,
+      }),
+    }))
+    .filter((v) => v.ids.length !== 0);
+
+  return [
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.TEST_SCENARIO_REVIEW,
+    },
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: StringUtil.trim`
+        # Available API Operations for Reference
+
+        Below are all available API operations and interface schemas for validation purposes.
+        Match each operation with its corresponding schema.
+
+        \`\`\`json
+        ${JSON.stringify({ operations: document.operations })}
+        \`\`\`
+      `,
+    },
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: StringUtil.trim`
+
+      # Test Scenario Groups
+
+      Please review the following test scenario groups:
+
+      \`\`\`json
+      ${JSON.stringify(
+        groups.map((g) => {
+          return {
+            ...g,
+            scenarios: g.scenarios.map((s) => {
+              const requiredId: string[] = [];
+
+              s.dependencies.forEach((dep) => {
+                document.operations.forEach((op) => {
+                  if (
+                    g.endpoint.method === op.method &&
+                    g.endpoint.path === op.path
+                  ) {
+                    requiredId.push(
+                      ...getReferenceIds({ document, operation: op }),
+                    );
+                  }
+
+                  if (
+                    op.method === dep.endpoint.method &&
+                    op.path === dep.endpoint.path
+                  ) {
+                    requiredId.push(
+                      ...getReferenceIds({ document, operation: op }),
+                    );
+                  }
+                });
+              });
+
+              return {
+                ...s,
+                requiredIds:
+                  requiredId.length > 0 ? Array.from(new Set(requiredId)) : [],
+              };
+            }),
+          };
+        }),
+      )}
+      \`\`\`
+      `,
+    },
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: StringUtil.trim`
+        # Candidate Dependencies
+    
+        List of candidate dependencies extracted from path parameters and request bodies.
+
+        Apply dependency resolution to the target endpoint from "Included in Test Plan" and to dependencies found recursively from it.
+        For each required ID, locate the operation that creates the resource. Include the creator only if that operation exists in the provided operations list. Do not assume or invent operations. If no creator exists, treat the ID as an external or pre-existing input.
+
+        Dependency resolution steps:
+        1. Starting from the target endpoint, collect required IDs.
+        2. For each ID, search for a creator operation (typically POST).
+        3. If found, add it to the dependency chain in execution order and repeat for its own required IDs.
+        4. Stop when no further creators exist or are needed.
+
+        For each some_entity_id pattern, use the same approach: include a creator only when it is present in the operations list.
+    
+        Endpoint | Required IDs (MUST be created by other APIs)
+        ---------|---------------------------------------------------
+        ${relationships
+          .map((r) =>
+            [
+              `\`${r.endpoint.method} ${r.endpoint.path}\``,
+              r.ids.map((id) => `\`${id}\``).join(", "),
+            ].join(" | "),
+          )
+          .join("\n")}
+
+        Example: If an endpoint requires \`articleId\` and \`POST /articles\` exists, include it in dependencies
+      `,
+    } satisfies IAgenticaHistoryJson.IAssistantMessage,
+  ];
+}

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -17,6 +17,7 @@ import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformTestScenarioHistories } from "./histories/transformTestScenarioHistories";
+import { orchestrateTestScenarioReview } from "./orchestrateTestScenarioReview";
 import { IAutoBeTestScenarioApplication } from "./structures/IAutoBeTestScenarioApplication";
 import { IAutoBeTestScenarioAuthorizationRole } from "./structures/IAutoBeTestScenarioAuthorizationRole";
 
@@ -31,8 +32,6 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
     );
   }
 
-  Object.entries(document.components.schemas);
-
   const dict: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation> =
     new HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>(
       document.operations.map(
@@ -63,6 +62,10 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
     total: document.operations.length,
     completed: 0,
   };
+  const reviewProgress: AutoBeProgressEventBase = {
+    total: document.operations.length,
+    completed: 0,
+  };
   const exclude: IAutoBeTestScenarioApplication.IScenarioGroup[] = [];
   let include: AutoBeOpenApi.IOperation[] = [...document.operations];
   let trial: number = 0;
@@ -82,6 +85,7 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
             include,
             exclude: exclude.map((x) => x.endpoint),
             progress,
+            reviewProgress,
             promptCacheKey,
           })),
         );
@@ -99,6 +103,7 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
       return true;
     });
     progress.total = include.length + exclude.length;
+    reviewProgress.total = include.length + exclude.length;
   } while (include.length > 0 && ++trial < ctx.retry);
 
   return exclude.flatMap((pg) => {
@@ -122,6 +127,7 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
     include: AutoBeOpenApi.IOperation[];
     exclude: AutoBeOpenApi.IEndpoint[];
     progress: AutoBeProgressEventBase;
+    reviewProgress: AutoBeProgressEventBase;
     promptCacheKey: string;
   },
 ): Promise<IAutoBeTestScenarioApplication.IScenarioGroup[]> => {
@@ -187,7 +193,11 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
       step: ctx.state().interface?.step ?? 0,
       created_at: new Date().toISOString(),
     });
-    return pointer.value;
+    return await orchestrateTestScenarioReview(
+      ctx,
+      pointer.value,
+      props.reviewProgress,
+    );
   } catch {
     return [];
   }