@autobe/agent 0.25.7 → 0.27.0

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

@@ -1,294 +1,29 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBeOpenApi } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+
 export const transformRealizeWriteAuthorizationsHistories = (
   operation: AutoBeOpenApi.IOperation,
-  payloads: Record<string, string>,
+  payload: Record<string, string>,
 ): Array<IAgenticaHistoryJson.ISystemMessage> => {
-  // Login operation 가이드
-  const loginGuide =
-    operation.authorizationType === "login"
-      ? [
-          {
-            id: v7(),
-            created_at: new Date().toISOString(),
-            type: "systemMessage" as const,
-            text: StringUtil.trim`
-              # Authorization Type: Login
-
-              This is a **login** operation that authenticates users.
-
-              ## Implementation Guidelines for Login:
-
-              ### Login Operation Requirements
-              - This is a login endpoint that authenticates users
-              - Must validate credentials (username/email and password)
-              - Should return authentication tokens (access and refresh tokens)
-              - Must NOT require authentication decorator (this endpoint creates authentication)
-              - Should check if user exists and password matches
-
-              ### MANDATORY: Use PasswordUtil for Password Verification
-              
-              **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 PasswordUtil.verify(
-                body.password,           // plain password from request
-                user.password_hash       // hashed password from database
-              );
-              
-              if (!isValid) {
-                throw new Error("Invalid credentials");
-              }
-              \`\`\`
-
-              ### JWT Token Generation
-              
-              **NOTE**: The jsonwebtoken library is automatically imported as jwt. Use it to generate tokens with the EXACT payload structure:
-
-              **CRITICAL**: Use the predefined payload structures for consistency:
-
-              \`\`\`json
-              ${JSON.stringify(payloads)}
-              \`\`\`
-
-              // JWT is already imported: import jwt from "jsonwebtoken";
-              
-              // Generate access token with the EXACT payload structure for the user type
-              // DO NOT use type annotations like: const payload: MemberPayload = {...}
-              // Just create the payload object directly
-              
-              const accessToken = jwt.sign(
-                {
-                  userId: user.id,
-                  email: user.email,
-                  // ... other required fields from the payload structure above
-                },
-                MyGlobal.env.JWT_SECRET_KEY,
-                {
-                  expiresIn: '1h',
-                  issuer: 'autobe'  // MUST use 'autobe' as issuer
-                }
-              );
-
-              // Generate refresh token (optional)
-              const refreshToken = jwt.sign(
-                {
-                  userId: user.id,
-                  tokenType: 'refresh'
-                },
-                MyGlobal.env.JWT_SECRET_KEY,
-                {
-                  expiresIn: '7d',
-                  issuer: 'autobe'  // MUST use 'autobe' as issuer
-                }
-              );
-
-              // Decode tokens if needed (e.g., for verification)
-              const decoded = jwt.verify(token, MyGlobal.env.JWT_SECRET_KEY, {
-                issuer: 'autobe'  // Verify issuer is 'autobe'
-              });
-
-              **DO NOT**:
-              - Implement your own password hashing logic
-              - Use bcrypt, argon2, or any other hashing library directly
-              - Try to hash and compare manually
-
-              **IMPORTANT**: Since this is a login operation, it must be publicly accessible without authentication.
-            `,
-          },
-        ]
-      : [];
-
-  // Join (registration) operation 가이드
-  const joinGuide =
-    operation.authorizationType === "join"
-      ? [
-          {
-            id: v7(),
-            created_at: new Date().toISOString(),
-            type: "systemMessage" as const,
-            text: StringUtil.trim`
-              # Authorization Type: Join (Registration)
-
-              This is a **join** operation for user registration.
-
-              ## Implementation Guidelines for Join:
-
-              ### Join (Registration) Operation Requirements
-              - This is a user registration endpoint
-              - Must validate all required user information
-              - Should check for duplicate accounts (email, username, etc.)
-              - Must hash passwords before storing (NEVER store plain passwords)
-              - Should create a new user record in the database
-              - Must NOT require authentication decorator (public endpoint)
-
-              ### MANDATORY: Use PasswordUtil for Password Hashing
-              
-              **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 PasswordUtil.hash(body.password);
-              
-              // Store the hashed password in database
-              await MyGlobal.prisma.users.create({
-                data: {
-                  email: body.email,
-                  password_hash: hashedPassword,  // Store the hash, never plain password
-                  // ... other fields
-                }
-              });
-              \`\`\`
-
-              **DO NOT**:
-              - Store plain passwords in the database
-              - Use bcrypt, argon2, or any other hashing library directly
-              - Implement your own hashing logic
-
-              ### JWT Token Generation After Registration
-              
-              **NOTE**: The jsonwebtoken library is automatically imported as jwt. After successful registration, generate tokens with the EXACT payload structure:
-
-              **CRITICAL**: Use the predefined payload structures for consistency:
-
-              \`\`\`json
-              ${JSON.stringify(payloads)}
-              \`\`\`
-
-              // JWT is already imported: import jwt from "jsonwebtoken";
-              
-              // After creating the user, generate tokens with EXACT payload structure
-              // DO NOT use type annotations like: const payload: UserPayload = {...}
-              // Just create the payload object directly in jwt.sign()
-              
-              const accessToken = jwt.sign(
-                {
-                  userId: newUser.id,
-                  email: newUser.email,
-                  // ... other required fields from the payload structure above
-                },
-                MyGlobal.env.JWT_SECRET_KEY,
-                {
-                  expiresIn: '1h',
-                  issuer: 'autobe'  // MUST use 'autobe' as issuer
-                }
-              );
-
-              const refreshToken = jwt.sign(
-                {
-                  userId: newUser.id,
-                  tokenType: 'refresh'
-                },
-                MyGlobal.env.JWT_SECRET_KEY,
-                {
-                  expiresIn: '7d',
-                  issuer: 'autobe'  // MUST use 'autobe' as issuer
-                }
-              );
-
-              **IMPORTANT**: Since this is a registration operation, it must be publicly accessible. Always hash passwords before storing.
-            `,
-          },
-        ]
-      : [];
-
-  // Refresh token operation 가이드
-  const refreshGuide =
-    operation.authorizationType === "refresh"
-      ? [
-          {
-            id: v7(),
-            created_at: new Date().toISOString(),
-            type: "systemMessage" as const,
-            text: StringUtil.trim`
-              # Authorization Type: Refresh Token
-
-              This is a **refresh** token operation for renewing expired access tokens.
-
-              ## Implementation Guidelines for Refresh:
-
-              ### Refresh Token Operation Requirements
-              - This endpoint refreshes expired access tokens
-              - Must validate the refresh token first
-              - Should check if refresh token is not expired or revoked
-              - Must generate a new access token with THE SAME payload structure
-              - May also rotate the refresh token for security
-              - Should handle invalid/expired refresh tokens gracefully
-              - Typically requires the refresh token in request body or headers
-              - Must NOT require standard authentication (uses refresh token instead)
-
-              ### CRITICAL: Refresh Token Implementation
-
-              **IMPORTANT**: When refreshing tokens, you MUST:
-              1. Decode and verify the refresh token
-              2. Extract the user information from the decoded token
-              3. Generate a new access token with THE SAME payload structure as the original
-
-              **CRITICAL**: Use the predefined payload structures for consistency:
-
-              \`\`\`json
-              ${JSON.stringify(payloads)}
-              \`\`\`
-
-              // JWT is already imported: import jwt from "jsonwebtoken";
-              
-              // Step 1: Verify and decode the refresh token
-              const decoded = jwt.verify(body.refreshToken, MyGlobal.env.JWT_SECRET_KEY, {
-                issuer: 'autobe'
-              });
-              
-              // Step 2: Get user data (from decoded token or database)
-              const user = await MyGlobal.prisma.users.findUnique({
-                where: { id: decoded.userId }
-              });
-              
-              if (!user) {
-                throw new Error("User not found");
-              }
-              
-              // Step 3: Generate new access token with SAME payload structure as login/join
-              const newAccessToken = jwt.sign(
-                {
-                  userId: user.id,
-                  email: user.email,
-                  // ... other required fields from the payload structure above
-                  // MUST match the structure used in login/join operations
-                },
-                MyGlobal.env.JWT_SECRET_KEY,
-                {
-                  expiresIn: '1h',
-                  issuer: 'autobe'
-                }
-              );
-              
-              // Optional: Rotate refresh token
-              const newRefreshToken = jwt.sign(
-                {
-                  userId: user.id,
-                  tokenType: 'refresh'
-                },
-                MyGlobal.env.JWT_SECRET_KEY,
-                {
-                  expiresIn: '7d',
-                  issuer: 'autobe'
-                }
-              );
-
-              **DO NOT**:
-              - Generate new access tokens with different payload structures
-              - Use random IDs like v4() in the payload
-              - Create tokens without verifying the refresh token first
-              - Use type annotations like: const payload: UserPayload = {...}
-
-              **IMPORTANT**: The new access token MUST have the same payload structure as the original token from login/join operations.
-            `,
-          },
-        ]
-      : [];
+  if (operation.authorizationType === null) return [];
+  const text: string = PROMPTS[operation.authorizationType].replace(
+    "${PAYLOAD}",
+    JSON.stringify(payload),
+  );
+  const history: IAgenticaHistoryJson.ISystemMessage = {
+    id: v7(),
+    created_at: new Date().toISOString(),
+    type: "systemMessage" as const,
+    text,
+  };
+  return [history];
+};
 
-  return [...loginGuide, ...joinGuide, ...refreshGuide];
+const PROMPTS = {
+  login: AutoBeSystemPromptConstant.REALIZE_MEMBERSHIP_LOGIN,
+  join: AutoBeSystemPromptConstant.REALIZE_MEMBERSHIP_JOIN,
+  refresh: AutoBeSystemPromptConstant.REALIZE_MEMBERSHIP_REFRESH,
 };

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -13,13 +13,13 @@ import { ILlmSchema } from "@samchon/openapi";
 import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeFacadeApplicationProps } from "../../context/IAutoBeFacadeApplicationProps";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { predicateStateMessage } from "../../utils/predicateStateMessage";
+import { IAutoBeFacadeApplicationProps } from "../facade/histories/IAutoBeFacadeApplicationProps";
 import { compileRealizeFiles } from "./internal/compileRealizeFiles";
-import { orchestrateRealizeCorrectCasting } from "./orchestRateRealizeCorrectCasting";
 import { orchestrateRealizeAuthorization } from "./orchestrateRealizeAuthorization";
 import { orchestrateRealizeCorrect } from "./orchestrateRealizeCorrect";
+import { orchestrateRealizeCorrectCasting } from "./orchestrateRealizeCorrectCasting";
 import { orchestrateRealizeWrite } from "./orchestrateRealizeWrite";
 import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 import { generateRealizeScenario } from "./utils/generateRealizeScenario";
@@ -189,13 +189,14 @@ export const orchestrateRealize =
     return ctx.dispatch({
       type: "realizeComplete",
       id: v7(),
-      created_at: new Date().toISOString(),
       functions: bucket.corrected,
       authorizations,
       controllers,
       compiled: bucket.validate.result,
+      aggregates: ctx.getCurrentAggregates("realize"),
       step: ctx.state().analyze?.step ?? 0,
       elapsed: new Date().getTime() - start.getTime(),
+      created_at: new Date().toISOString(),
     });
   };
 

package/src/orchestrate/realize/orchestrateRealizeAuthorization.ts

@@ -1,6 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
-  AutoBeAnalyzeRole,
+  AutoBeAnalyzeActor,
   AutoBeProgressEventBase,
   AutoBeRealizeAuthorization,
   AutoBeRealizeAuthorizationWriteEvent,
@@ -36,9 +36,9 @@ export async function orchestrateRealizeAuthorization<
     created_at: new Date().toISOString(),
   });
 
-  const roles: AutoBeAnalyzeRole[] = ctx.state().analyze?.roles ?? [];
+  const actors: AutoBeAnalyzeActor[] = ctx.state().analyze?.actors ?? [];
   const progress: AutoBeProgressEventBase = {
-    total: roles.length,
+    total: actors.length,
     completed: 0,
   };
   const templateFiles = await (
@@ -47,11 +47,11 @@ export async function orchestrateRealizeAuthorization<
     dbms: "sqlite",
   });
   const authorizations: AutoBeRealizeAuthorization[] = await executeCachedBatch(
-    roles.map(
-      (role) => (promptCacheKey) =>
+    actors.map(
+      (a) => (promptCacheKey) =>
         process(
           ctx,
-          role,
+          a,
           InternalFileSystem.DEFAULT.map((el) => ({
             [el]: templateFiles[el],
           })).reduce((acc, cur) => Object.assign(acc, cur), {}),
@@ -71,7 +71,7 @@ export async function orchestrateRealizeAuthorization<
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  role: AutoBeAnalyzeRole,
+  actor: AutoBeAnalyzeActor,
   templateFiles: Record<string, string>,
   progress: AutoBeProgressEventBase,
   promptCacheKey: string,
@@ -80,9 +80,9 @@ async function process<Model extends ILlmSchema.Model>(
     {
       value: null,
     };
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: "realizeAuthorizationWrite",
-    histories: transformRealizeAuthorizationHistories(ctx, role),
+    histories: transformRealizeAuthorizationHistories(ctx, actor),
     controller: createController({
       model: ctx.model,
       build: (next) => {
@@ -97,7 +97,7 @@ async function process<Model extends ILlmSchema.Model>(
 
   const compiler: IAutoBeCompiler = await ctx.compiler();
   const authorization: AutoBeRealizeAuthorization = {
-    role,
+    actor: actor,
     decorator: {
       location: AuthorizationFileSystem.decoratorPath(
         pointer.value.decorator.name,
@@ -129,6 +129,7 @@ async function process<Model extends ILlmSchema.Model>(
     id: v7(),
     created_at: new Date().toISOString(),
     authorization: authorization,
+    metric,
     tokenUsage,
     completed: ++progress.completed,
     total: progress.total,

package/src/orchestrate/realize/orchestrateRealizeAuthorizationCorrect.ts

@@ -29,13 +29,13 @@ export async function orchestrateRealizeAuthorizationCorrect<
   const compiler: IAutoBeCompiler = await ctx.compiler();
   const providerContent: string = await compiler.typescript.beautify(
     AutoBeRealizeAuthorizationReplaceImport.replaceProviderImport(
-      authorization.role.name,
+      authorization.actor.name,
       authorization.provider.content,
     ),
   );
   const decoratorContent: string = await compiler.typescript.beautify(
     AutoBeRealizeAuthorizationReplaceImport.replaceDecoratorImport(
-      authorization.role.name,
+      authorization.actor.name,
       authorization.decorator.content,
     ),
   );
@@ -76,7 +76,7 @@ export async function orchestrateRealizeAuthorizationCorrect<
     {
       value: null,
     };
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: "realizeAuthorizationCorrect",
     histories: transformRealizeAuthorizationCorrectHistories(
       ctx,
@@ -116,7 +116,7 @@ export async function orchestrateRealizeAuthorizationCorrect<
         pointer.value.payload.content,
       ),
     },
-    role: authorization.role,
+    actor: authorization.actor,
   };
 
   ctx.dispatch({
@@ -126,6 +126,7 @@ export async function orchestrateRealizeAuthorizationCorrect<
     created_at: new Date().toISOString(),
     authorization: result,
     result: compiled,
+    metric,
     tokenUsage,
     step: ctx.state().test?.step ?? 0,
   });

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -34,7 +34,7 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
   scenarios: IAutoBeRealizeScenarioResult[],
   authorizations: AutoBeRealizeAuthorization[],
   functions: AutoBeRealizeFunction[],
-  failures: IAutoBeRealizeFunctionFailure[],
+  previousFailures: IAutoBeRealizeFunctionFailure[][],
   progress: AutoBeProgressEventBase,
   life: number = ctx.retry,
 ): Promise<AutoBeRealizeFunction[]> {
@@ -92,32 +92,26 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
     diagnosticsByFile[location].diagnostics.push(diagnostic);
   });
 
-  const newFailures: IAutoBeRealizeFunctionFailure[] = [
-    ...failures,
-    ...Object.values(diagnosticsByFile),
-  ];
-
-  const corrected: AutoBeRealizeFunction[] = await correct(
-    ctx,
+  const newFailures: IAutoBeRealizeFunctionFailure[] =
+    Object.values(diagnosticsByFile);
+  const corrected: AutoBeRealizeFunction[] = await correct(ctx, {
     locations,
     scenarios,
     authorizations,
     functions,
-    filterDiagnostics(
+    previousFailures,
+    failures: filterDiagnostics(
       newFailures,
       functions.map((fn) => fn.location),
     ),
     progress,
-  );
+  });
   return orchestrateRealizeCorrect(
     ctx,
     scenarios,
     authorizations,
     corrected,
-    filterDiagnostics(
-      newFailures,
-      corrected.map((c) => c.location),
-    ),
+    [...previousFailures, newFailures],
     progress,
     life - 1,
   );
@@ -125,61 +119,82 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
 
 async function correct<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  locations: string[],
-  scenarios: IAutoBeRealizeScenarioResult[],
-  authorizations: AutoBeRealizeAuthorization[],
-  functions: AutoBeRealizeFunction[],
-  failures: IAutoBeRealizeFunctionFailure[],
-  progress: AutoBeProgressEventBase,
+  props: {
+    locations: string[];
+    scenarios: IAutoBeRealizeScenarioResult[];
+    authorizations: AutoBeRealizeAuthorization[];
+    functions: AutoBeRealizeFunction[];
+    previousFailures: IAutoBeRealizeFunctionFailure[][];
+    failures: IAutoBeRealizeFunctionFailure[];
+    progress: AutoBeProgressEventBase;
+  },
 ): Promise<AutoBeRealizeFunction[]> {
-  if (locations.length === 0) {
-    return functions;
+  if (props.locations.length === 0) {
+    return props.functions;
   }
 
   const corrected: AutoBeRealizeFunction[] = await executeCachedBatch(
-    locations.map((location) => async (): Promise<AutoBeRealizeFunction> => {
-      const scenario = scenarios.find((el) => el.location === location);
-      const func = functions.find((el) => el.location === location);
+    props.locations.map(
+      (location) => async (): Promise<AutoBeRealizeFunction> => {
+        const scenario = props.scenarios.find((el) => el.location === location);
+        const func = props.functions.find((el) => el.location === location);
 
-      if (!func) {
-        throw new Error("No function found for location: " + location);
-      }
+        if (!func) {
+          throw new Error("No function found for location: " + location);
+        }
 
-      const RealizeFunctionFailures: IAutoBeRealizeFunctionFailure[] =
-        failures.filter((f) => f.function?.location === location);
-
-      if (RealizeFunctionFailures.length && scenario) {
-        try {
-          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;
+        const failures: IAutoBeRealizeFunctionFailure[] = props.failures.filter(
+          (f) => f.function?.location === location,
+        );
+        if (failures.length && scenario) {
+          try {
+            const correctEvent: AutoBeRealizeCorrectEvent | null = await step(
+              ctx,
+              {
+                totalAuthorizations: props.authorizations,
+                authorization: scenario.decoratorEvent ?? null,
+                scenario,
+                function: func,
+                previousFailures: props.previousFailures
+                  .map((pf) => {
+                    const previousFailures: IAutoBeRealizeFunctionFailure[] =
+                      pf.filter((f) => f.function.location === location);
+                    if (previousFailures.length === 0) return null;
+                    return {
+                      function: previousFailures[0].function,
+                      diagnostics: previousFailures
+                        .map((f) => f.diagnostics)
+                        .flat(),
+                    };
+                  })
+                  .filter((f) => f !== null),
+                failure: {
+                  function: failures[0].function,
+                  diagnostics: failures.map((f) => f.diagnostics).flat(),
+                },
+                progress: props.progress,
+              },
+            );
+
+            return {
+              ...func,
+              content: correctEvent === null ? "" : correctEvent.content,
+            };
+          } catch (err) {
+            return func;
+          }
         }
-      }
 
-      return func;
-    }),
+        return func;
+      },
+    ),
   );
 
   // Create a map of corrected functions for efficient lookup
   const correctedMap = new Map(corrected.map((f) => [f.location, f]));
 
   // Return all functions, with corrected ones replaced
-  return functions.map((func) => correctedMap.get(func.location) || func);
+  return props.functions.map((func) => correctedMap.get(func.location) || func);
 }
 
 async function step<Model extends ILlmSchema.Model>(
@@ -189,7 +204,8 @@ async function step<Model extends ILlmSchema.Model>(
     totalAuthorizations: AutoBeRealizeAuthorization[];
     scenario: IAutoBeRealizeScenarioResult;
     function: AutoBeRealizeFunction;
-    failures: IAutoBeRealizeFunctionFailure[];
+    previousFailures: IAutoBeRealizeFunctionFailure[];
+    failure: IAutoBeRealizeFunctionFailure;
     progress: AutoBeProgressEventBase;
   },
 ): Promise<AutoBeRealizeCorrectEvent | null> {
@@ -198,7 +214,7 @@ async function step<Model extends ILlmSchema.Model>(
   };
 
   const dto = await getRealizeWriteDto(ctx, props.scenario.operation);
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: "realizeCorrect",
     controller: createController({
       model: ctx.model,
@@ -211,11 +227,8 @@ async function step<Model extends ILlmSchema.Model>(
       state: ctx.state(),
       scenario: props.scenario,
       authorization: props.authorization,
-      code: props.function.content,
       dto,
-      failures: props.failures.filter(
-        (f) => f.function.location === props.function.location,
-      ),
+      failures: [...props.previousFailures, props.failure],
       totalAuthorizations: props.totalAuthorizations,
     }),
     enforceFunctionCall: true,
@@ -226,7 +239,7 @@ async function step<Model extends ILlmSchema.Model>(
       When modifying, modify the entire code, but not the import statement.
 
       Below is template code you wrote:
-      
+
       ${getRealizeWriteCodeTemplate({
         scenario: props.scenario,
         schemas: ctx.state().interface!.document.components.schemas,
@@ -261,9 +274,11 @@ async function step<Model extends ILlmSchema.Model>(
 
   const event: AutoBeRealizeCorrectEvent = {
     type: "realizeCorrect",
+    kind: "overall",
     id: v7(),
     location: props.scenario.location,
     content: pointer.value.revise.final ?? pointer.value.draft,
+    metric,
     tokenUsage,
     completed: ++props.progress.completed,
     total: props.progress.total,