@autobe/agent 0.25.7 → 0.26.0

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

@@ -1,44 +1,30 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
-import { printErrorHints } from "../utils/printErrorHints";
+import { transformPreviousAndLatestCorrectHistories } from "../../common/histories/transformPreviousAndLatestCorrectHistories";
+import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
 
-interface IFailure {
-  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[];
-  script: string;
-}
-
-export const transformRealizeCorrectCastingHistories = (
-  failures: IFailure[],
-): Array<
+export const transformRealizeCorrectCastingHistories = (props: {
+  failures: IAutoBeRealizeFunctionFailure[];
+}): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
-  return [
+  const histories: Array<
+    IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+  > = [
     {
       id: v7(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
       text: AutoBeSystemPromptConstant.COMMON_CORRECT_CASTING,
     },
-    ...failures.map(
-      (f) =>
-        ({
-          id: v7(),
-          created_at: new Date().toISOString(),
-          type: "assistantMessage",
-          text: StringUtil.trim`
-          # 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,
+    ...transformPreviousAndLatestCorrectHistories(
+      props.failures.map((f) => ({
+        script: f.function.content,
+        diagnostics: f.diagnostics,
+      })),
     ),
   ];
+  return histories;
 };

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

@@ -1,13 +1,12 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBeRealizeAuthorization } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
+import { transformPreviousAndLatestCorrectHistories } from "../../common/histories/transformPreviousAndLatestCorrectHistories";
 import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
-import { printErrorHints } from "../utils/printErrorHints";
 import { transformRealizeWriteHistories } from "./transformRealizeWriteHistories";
 
 export function transformRealizeCorrectHistories(props: {
@@ -15,49 +14,33 @@ export function transformRealizeCorrectHistories(props: {
   scenario: IAutoBeRealizeScenarioResult;
   authorization: AutoBeRealizeAuthorization | null;
   totalAuthorizations: AutoBeRealizeAuthorization[];
-  code: string;
   dto: Record<string, string>;
   failures: IAutoBeRealizeFunctionFailure[];
 }): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > {
-  return [
+  const histories: Array<
+    IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+  > = [
     ...transformRealizeWriteHistories(props),
     {
       id: v7(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
       text: AutoBeSystemPromptConstant.COMMON_CORRECT_CASTING,
-    },
-    {
-      id: v7(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
-        Below is the code you made before. It's also something to review.
-
-        \`\`\`typescript
-        ${props.code}
-        \`\`\`
-      `,
-      created_at: new Date().toISOString(),
-    },
-    ...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;
-    }),
+    } as IAgenticaHistoryJson.ISystemMessage,
     {
       id: v7(),
       type: "systemMessage",
       text: AutoBeSystemPromptConstant.REALIZE_CORRECT,
       created_at: new Date().toISOString(),
-    },
+    } as IAgenticaHistoryJson.ISystemMessage,
+    ...transformPreviousAndLatestCorrectHistories(
+      props.failures.map((f) => ({
+        script: f.function.content,
+        diagnostics: f.diagnostics,
+      })),
+    ),
   ];
+  return histories;
 }

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

@@ -17,9 +17,9 @@ import { IAutoBeFacadeApplicationProps } from "../../context/IAutoBeFacadeApplic
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { predicateStateMessage } from "../../utils/predicateStateMessage";
 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";

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,
@@ -82,7 +82,7 @@ async function process<Model extends ILlmSchema.Model>(
     };
   const { 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,

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,
     ),
   );
@@ -116,7 +116,7 @@ export async function orchestrateRealizeAuthorizationCorrect<
         pointer.value.payload.content,
       ),
     },
-    role: authorization.role,
+    actor: authorization.actor,
   };
 
   ctx.dispatch({