@autobe/agent 0.25.0 → 0.25.2

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

@@ -11,7 +11,8 @@ export namespace JsonSchemaValidator {
   }
 
   export const validateSchemas = (props: IProps): void => {
-    authorization(props);
+    validateAuthorization(props);
+    validatePrismaSchema(props.errors);
     for (const key of Object.keys(props.schemas))
       validateKey({
         errors: props.errors,
@@ -41,7 +42,25 @@ export namespace JsonSchemaValidator {
           it to a valid variable name at the next time.
         `,
       });
-    if (props.key === "IPageIRequest")
+    if (props.key.endsWith(".IPage")) {
+      const expected: string = `IPage${props.key.substring(0, props.key.length - 6)}`;
+      props.errors.push({
+        path: `${props.path}[${JSON.stringify(props.key)}]`,
+        expected: `"IPage" must be followed by another interface name. Use ${JSON.stringify(expected)} instead.`,
+        value: props.key,
+        description: StringUtil.trim`
+          "IPage" is a reserved type name for pagination response.
+          The pagination data type name must be post-fixed after "IPage".
+          
+          However, you've defined ${JSON.stringify(props.key)}, 
+          post-fixing ".IPage" after the pagination data type name.
+
+          Change it to a valid pagination type name to be
+          ${JSON.stringify(expected)} at the next time. Note that,
+          this is not a recommendation, but an instruction you must follow.
+        `,
+      });
+    } else if (props.key === "IPageIRequest")
       props.errors.push({
         path: `${props.path}[${JSON.stringify(props.key)}]`,
         expected: `"IPageIRequest" is a mistake. Use "IPage.IRequest" instead.`,
@@ -103,7 +122,7 @@ export namespace JsonSchemaValidator {
     }
   };
 
-  const authorization = (props: IProps): void => {
+  const validateAuthorization = (props: IProps): void => {
     for (const [key, value] of Object.entries(props.schemas)) {
       if (!key.endsWith(".IAuthorized")) continue;
       else if (AutoBeOpenApiTypeChecker.isObject(value) === false) {
@@ -128,4 +147,31 @@ export namespace JsonSchemaValidator {
         value.required.push("token");
     }
   };
+
+  const validatePrismaSchema = (errors: IValidation.IError[]): void => {
+    for (const e of errors) {
+      if (e.path.endsWith(`.properties["x-autobe-prisma-schema"]`) === false)
+        continue;
+      e.expected =
+        "undefined value (remove this property and re-define it in the root schema)";
+      e.description = StringUtil.trim`
+        You have defined a property named "x-autobe-prisma-schema"
+        somewhere wrong place.
+        
+        You have defined a property name "x-autobe-prisma-schema" as 
+        an object type. However, this "x-autobe-prisma-schema" property
+        must be defined only in the root schema object as a metadata,
+        not in the nested object property.
+
+        Remove this property at the next time, and re-define it in the
+        root object schema.
+        
+        - Current path (wrong): ${e.path}
+        - Must be (object root): ${e.path.replace(
+          `.properties["x-autobe-prisma-schema"]`,
+          `["x-autobe-prisma-schema"]`,
+        )} 
+      `;
+    }
+  };
 }

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

@@ -1,5 +1,5 @@
 import { AutoBeOpenApi } from "@autobe/interface";
-import { AutoBeEndpointComparator, StringUtil } from "@autobe/utils";
+import { AutoBeOpenApiEndpointComparator, StringUtil } from "@autobe/utils";
 import { HashMap } from "tstl";
 import { IValidation } from "typia";
 import { Escaper } from "typia/lib/utils/Escaper";
@@ -8,14 +8,16 @@ import { emplaceMap } from "../../../utils/emplaceMap";
 import { JsonSchemaValidator } from "./JsonSchemaValidator";
 
 export namespace OperationValidator {
-  export interface IProps {
+  export const validate = (props: {
     errors: IValidation.IError[];
     path: string;
     operations: Array<
-      Omit<AutoBeOpenApi.IOperation, "authorizationRole" | "authorizationType">
+      Omit<
+        AutoBeOpenApi.IOperation,
+        "authorizationRole" | "authorizationType" | "prerequisites"
+      >
     >;
-  }
-  export const validate = (props: IProps): void => {
+  }): void => {
     props.operations.forEach((op, i) => {
       // get method has request body
       if (op.method === "get" && op.requestBody !== null)
@@ -59,8 +61,8 @@ export namespace OperationValidator {
 
     // validate duplicated endpoints
     const endpoints: HashMap<AutoBeOpenApi.IEndpoint, number[]> = new HashMap(
-      AutoBeEndpointComparator.hashCode,
-      AutoBeEndpointComparator.equals,
+      AutoBeOpenApiEndpointComparator.hashCode,
+      AutoBeOpenApiEndpointComparator.equals,
     );
     props.operations.forEach((op, i) => {
       const key: AutoBeOpenApi.IEndpoint = {

package/src/orchestrate/realize/histories/transformRealizeCorrectCastingHistories.ts

@@ -4,6 +4,7 @@ import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { printErrorHints } from "../utils/printErrorHints";
 
 interface IFailure {
   diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[];
@@ -20,23 +21,21 @@ export const transformRealizeCorrectCastingHistories = (
       id: v7(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
-      text: AutoBeSystemPromptConstant.REALIZE_CORRECT_CASTING,
+      text: AutoBeSystemPromptConstant.COMMON_CORRECT_CASTING,
     },
     ...failures.map(
-      (f, i, array) =>
+      (f) =>
         ({
           id: v7(),
           created_at: new Date().toISOString(),
           type: "assistantMessage",
           text: StringUtil.trim`
-          # ${i === array.length - 1 ? "Latest Failure" : "Previous Failure"}
-          ## Generated TypeScript Code
-          \`\`\`typescript
-          ${f.script}
-          \`\`\`
-          ## Compile Errors
-          \`\`\`json
-          ${JSON.stringify(f.diagnostics)}
+          # Errors
+
+          This is a past code and an error with the code. 
+          Please refer to the annotation for the location of the error.
+
+          ${printErrorHints(f.script, f.diagnostics)}          
           \`\`\`
         `,
         }) satisfies IAgenticaHistoryJson.IAssistantMessage,

package/src/orchestrate/realize/histories/transformRealizeCorrectHistories.ts

@@ -7,6 +7,7 @@ import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromp
 import { AutoBeState } from "../../../context/AutoBeState";
 import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
+import { printErrorHints } from "../utils/printErrorHints";
 import { transformRealizeWriteHistories } from "./transformRealizeWriteHistories";
 
 export function transformRealizeCorrectHistories(props: {
@@ -40,30 +41,18 @@ export function transformRealizeCorrectHistories(props: {
       `,
       created_at: new Date().toISOString(),
     },
-    ...props.failures.map(
-      (f) =>
-        ({
-          id: v7(),
-          type: "assistantMessage",
-          text: StringUtil.trim`
-
-      ## Generated Typescript Code
-
-      \`\`\`typescript
-      ${f.function.content}
-      \`\`\`
-
-      ## Compile Errors
-
-      Fix the comilation error in the provided code.
-
-      \`\`\`typescript
-      ${JSON.stringify(f.diagnostics)}
-      \`\`\`
-      `,
-          created_at: new Date().toISOString(),
-        }) satisfies IAgenticaHistoryJson.IAssistantMessage,
-    ),
+    ...props.failures.map((f) => {
+      return {
+        id: v7(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+            This is a past code and an error with the code. Please refer to the annotation for the location of the error.
+
+            ${printErrorHints(f.function.content, f.diagnostics)}
+          `,
+        created_at: new Date().toISOString(),
+      } satisfies IAgenticaHistoryJson.IAssistantMessage;
+    }),
     {
       id: v7(),
       type: "systemMessage",

package/src/orchestrate/realize/histories/transformRealizeWriteAuthorizationsHistories.ts

@@ -29,13 +29,13 @@ export const transformRealizeWriteAuthorizationsHistories = (
               - Must NOT require authentication decorator (this endpoint creates authentication)
               - Should check if user exists and password matches
 
-              ### MANDATORY: Use MyGlobal.password for Password Verification
+              ### MANDATORY: Use PasswordUtil for Password Verification
               
-              **CRITICAL**: You MUST use MyGlobal.password utilities for password verification to ensure consistency with the join operation:
+              **CRITICAL**: You MUST use PasswordUtil utilities for password verification to ensure consistency with the join operation:
 
               \`\`\`typescript
               // Example: Password verification in login
-              const isValid = await MyGlobal.password.verify(
+              const isValid = await PasswordUtil.verify(
                 body.password,           // plain password from request
                 user.password_hash       // hashed password from database
               );
@@ -126,13 +126,13 @@ export const transformRealizeWriteAuthorizationsHistories = (
               - Should create a new user record in the database
               - Must NOT require authentication decorator (public endpoint)
 
-              ### MANDATORY: Use MyGlobal.password for Password Hashing
+              ### MANDATORY: Use PasswordUtil for Password Hashing
               
-              **CRITICAL**: You MUST use MyGlobal.password utilities for password hashing to ensure consistency across all authentication operations:
+              **CRITICAL**: You MUST use PasswordUtil utilities for password hashing to ensure consistency across all authentication operations:
 
               \`\`\`typescript
               // Example: Password hashing in join/registration
-              const hashedPassword = await MyGlobal.password.hash(body.password);
+              const hashedPassword = await PasswordUtil.hash(body.password);
               
               // Store the hashed password in database
               await MyGlobal.prisma.users.create({

package/src/orchestrate/realize/histories/transformRealizeWriteHistories.ts

@@ -100,6 +100,7 @@ export const transformRealizeWriteHistories = (props: {
   const authorizationHistories = operation.authorizationType
     ? transformRealizeWriteAuthorizationsHistories(operation, payloads)
     : [];
+  const document = props.state.interface.document;
 
   return [
     {
@@ -127,11 +128,12 @@ export const transformRealizeWriteHistories = (props: {
       id: v7(),
       type: "systemMessage",
       created_at: new Date().toISOString(),
-      text: getRealizeWriteCodeTemplate(
-        props.scenario,
+      text: getRealizeWriteCodeTemplate({
+        authorization: props.authorization,
+        scenario: props.scenario,
+        schemas: document.components.schemas,
         operation,
-        props.authorization,
-      ),
+      }),
     },
     {
       id: v7(),

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

@@ -47,13 +47,11 @@ export async function compileRealizeFiles<Model extends ILlmSchema.Model>(
       props.functions.map((el) => [el.location, el.content]),
     ),
   };
-
   const compiled: IAutoBeTypeScriptCompileResult =
     await compiler.typescript.compile({
       files: files,
     });
-
-  const event: AutoBeRealizeValidateEvent = {
+  return {
     type: "realizeValidate",
     id: v7(),
     files: files,
@@ -61,6 +59,4 @@ export async function compileRealizeFiles<Model extends ILlmSchema.Model>(
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   };
-
-  return event;
 }

package/src/orchestrate/realize/orchestRateRealizeCorrectCasting.ts

@@ -17,6 +17,9 @@ import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { IAutoBeCommonCorrectCastingApplication } from "../common/structures/IAutoBeCommonCorrectCastingApplication";
 import { transformRealizeCorrectCastingHistories } from "./histories/transformRealizeCorrectCastingHistories";
 import { compileRealizeFiles } from "./internal/compileRealizeFiles";
+import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
+import { getRealizeWriteCodeTemplate } from "./utils/getRealizeWriteCodeTemplate";
+import { replaceImportStatements } from "./utils/replaceImportStatements";
 
 /** Result of attempting to correct a single function */
 type CorrectionResult = {
@@ -28,6 +31,7 @@ export const orchestrateRealizeCorrectCasting = async <
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
+  scenarios: IAutoBeRealizeScenarioResult[],
   authorizations: AutoBeRealizeAuthorization[],
   functions: AutoBeRealizeFunction[],
   progress: AutoBeProgressEventBase,
@@ -40,9 +44,9 @@ export const orchestrateRealizeCorrectCasting = async <
       functions,
     },
   );
-
   return predicate(
     ctx,
+    scenarios,
     authorizations,
     functions,
     [],
@@ -54,6 +58,7 @@ export const orchestrateRealizeCorrectCasting = async <
 
 const predicate = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  scenarios: IAutoBeRealizeScenarioResult[],
   authorizations: AutoBeRealizeAuthorization[],
   functions: AutoBeRealizeFunction[],
   failures: IAutoBeTypeScriptCompileResult.IDiagnostic[],
@@ -63,9 +68,9 @@ const predicate = async <Model extends ILlmSchema.Model>(
 ): Promise<AutoBeRealizeFunction[]> => {
   if (event.result.type === "failure") {
     ctx.dispatch(event);
-
     return await correct(
       ctx,
+      scenarios,
       authorizations,
       functions,
       [...failures, ...event.result.diagnostics],
@@ -79,6 +84,7 @@ const predicate = async <Model extends ILlmSchema.Model>(
 
 const correct = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  scenarios: IAutoBeRealizeScenarioResult[],
   authorizations: AutoBeRealizeAuthorization[],
   functions: AutoBeRealizeFunction[],
   failures: IAutoBeTypeScriptCompileResult.IDiagnostic[],
@@ -94,12 +100,12 @@ const correct = async <Model extends ILlmSchema.Model>(
   const locations: string[] = diagnose(event).filter((l) =>
     functions.map((f) => f.location).includes(l),
   );
-  
+
   // If no locations to correct, return original functions
   if (locations.length === 0) {
     return functions;
   }
-  
+
   progress.total += locations.length;
 
   const converted: CorrectionResult[] = await executeCachedBatch(
@@ -108,6 +114,13 @@ const correct = async <Model extends ILlmSchema.Model>(
         (f) => f.location === location,
       )!;
 
+      const scenario = scenarios.find((s) => s.location === func.location)!;
+
+      const operation = scenario.operation;
+      const authorization = authorizations.find(
+        (a) => a.role.name === operation.authorizationRole,
+      );
+
       const pointer: IPointer<
         IAutoBeCommonCorrectCastingApplication.IProps | false | null
       > = {
@@ -143,18 +156,62 @@ const correct = async <Model extends ILlmSchema.Model>(
 
           You don't need to explain me anything, but just fix or give it up 
           immediately without any hesitation, explanation, and questions.
+
+          The instruction to write at first was as follows, and the code you received is the code you wrote according to this instruction.
+          When modifying, modify the entire code, but not the import statement.
+
+          Below is template code you wrote:
+
+          ${getRealizeWriteCodeTemplate({
+            scenario,
+            schemas: ctx.state().interface!.document.components.schemas,
+            operation: scenario.operation,
+            authorization: authorization ?? null,
+          })}
+
+          Current code is as follows:
+
+          \`\`\`typescript
+          ${func.content}
+          \`\`\`
+
+          Also, never use typia.assert and typia.assertGuard like functions
+          to the Prisma types. Your mission is to fix the casting problem of
+          primitive types like string or number. Prisma type is not your scope.
+          
+          If you take a mistake that casting the Prisma type with the typia.assert
+          function, it would be fallen into the infinite compilation due to extremely
+          complicated Prisma type. Note that, the typia.assert function is allowed 
+          only in the individual property level string or literal type.
+
+          I repeat that, never assert the Prisma type. It's not your mission.
         `,
       });
       ++progress.completed;
+
       if (pointer.value === null)
         return { result: "exception" as const, func: func };
       else if (pointer.value === false)
         return { result: "ignore" as const, func: func };
 
+      pointer.value.draft = await replaceImportStatements(ctx, {
+        schemas: ctx.state().interface!.document.components.schemas,
+        operation: operation,
+        code: pointer.value.draft,
+        decoratorType: authorization?.payload.name,
+      });
+      if (pointer.value.revise.final)
+        pointer.value.revise.final = await replaceImportStatements(ctx, {
+          schemas: ctx.state().interface!.document.components.schemas,
+          operation: operation,
+          code: pointer.value.revise.final,
+          decoratorType: authorization?.payload.name,
+        });
+
       ctx.dispatch({
         id: v7(),
         type: "realizeCorrect",
-        content: pointer.value.revise.final,
+        content: pointer.value.revise.final ?? pointer.value.draft,
         created_at: new Date().toISOString(),
         location: func.location,
         step: ctx.state().analyze?.step ?? 0,
@@ -162,25 +219,38 @@ const correct = async <Model extends ILlmSchema.Model>(
         completed: progress.completed,
         total: progress.total,
       });
-
       return {
         result: "success" as const,
-        func: { ...func, content: pointer.value.revise.final },
+        func: {
+          ...func,
+          content: pointer.value.revise.final ?? pointer.value.draft,
+        },
       };
     }),
   );
 
+  // Get functions that were not modified (not in locations array)
+  const unchangedFunctions: AutoBeRealizeFunction[] = functions.filter(
+    (f) => !locations.includes(f.location),
+  );
+
+  // Merge converted functions with unchanged functions for validation
+  const allFunctionsForValidation = [
+    ...converted.map((c) => c.func),
+    ...unchangedFunctions,
+  ];
+
   const newValidate: AutoBeRealizeValidateEvent = await compileRealizeFiles(
     ctx,
     {
       authorizations,
-      functions: converted.map((c) => c.func),
+      functions: allFunctionsForValidation,
     },
   );
 
   const newResult: IAutoBeTypeScriptCompileResult = newValidate.result;
   if (newResult.type === "success") {
-    return converted.map((c) => c.func);
+    return allFunctionsForValidation;
   } else if (newResult.type === "exception") {
     // Compilation exception, return current functions. because retrying won't help.
     return functions;
@@ -190,7 +260,7 @@ const correct = async <Model extends ILlmSchema.Model>(
     newResult.diagnostics.every((d) => !d.file?.startsWith("src/providers"))
   ) {
     // No diagnostics related to provider functions, stop correcting
-    return converted.map((c) => c.func);
+    return allFunctionsForValidation;
   }
 
   const newLocations: string[] = diagnose(newValidate);
@@ -201,9 +271,9 @@ const correct = async <Model extends ILlmSchema.Model>(
     newLocations,
   );
 
-  // If no failures to retry, return success and ignored functions
+  // If no failures to retry, return all functions
   if (failed.length === 0) {
-    return [...success, ...ignored];
+    return [...success, ...ignored, ...unchangedFunctions];
   }
 
   // Collect diagnostics relevant to failed functions
@@ -218,6 +288,7 @@ const correct = async <Model extends ILlmSchema.Model>(
   // Recursively retry failed functions
   const retriedFunctions: AutoBeRealizeFunction[] = await predicate(
     ctx,
+    scenarios,
     authorizations,
     failed,
     relevantDiagnostics,
@@ -226,11 +297,7 @@ const correct = async <Model extends ILlmSchema.Model>(
     life - 1,
   );
 
-  // Get functions that were not modified (not in converted array)
-  const convertedLocations = converted.map(c => c.func.location);
-  const unchanged = functions.filter(f => !convertedLocations.includes(f.location));
-
-  return [...success, ...ignored, ...retriedFunctions, ...unchanged];
+  return [...success, ...ignored, ...retriedFunctions, ...unchangedFunctions];
 };
 
 /**