@autobe/agent 0.22.1 → 0.23.1

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -3,7 +3,6 @@ import {
   AutoBeRealizeAuthorization,
   AutoBeRealizeCorrectEvent,
   AutoBeRealizeFunction,
-  AutoBeRealizeValidateEvent,
 } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmController, ILlmSchema } from "@samchon/openapi";
@@ -28,51 +27,75 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
   authorizations: AutoBeRealizeAuthorization[],
   functions: AutoBeRealizeFunction[],
   failures: IAutoBeRealizeFunctionFailure[],
-  progress: IProgress,
-  life: number = 5,
-): Promise<AutoBeRealizeValidateEvent> {
-  const event = await compileRealizeFiles(ctx, { authorizations, functions });
-  if (event.result.type === "failure") ctx.dispatch(event);
-
-  if (event.result.type === "success") {
-    console.debug("compilation success!");
-    return event;
-  } else if (--life <= 0) return event;
-
-  const locations: string[] =
-    (event.result.type === "failure"
-      ? Array.from(new Set(event.result.diagnostics.map((d) => d.file)))
-      : null
-    )?.filter((el) => el !== null) ?? [];
-
-  progress.total += Object.keys(locations).length;
-
-  const diagnostics =
-    event.result.type === "failure" ? event.result.diagnostics : [];
-
-  const diagnosticsByFile = diagnostics.reduce<
-    Record<string, typeof diagnostics>
-  >((acc, diagnostic) => {
-    const location = diagnostic.file!;
-    if (!acc[location]) {
-      acc[location] = [];
-    }
-    acc[location].push(diagnostic);
-    return acc;
-  }, {});
+  progress: AutoBeProgressEventBase,
+  life: number = ctx.retry,
+): Promise<AutoBeRealizeFunction[]> {
+  const event = await compileRealizeFiles(ctx, {
+    authorizations,
+    functions,
+  });
+
+  if (event.result.type !== "failure") return functions;
+  else if (life < 0) return functions;
 
-  for (const [location, diagnostics] of Object.entries(diagnosticsByFile)) {
-    const func = functions.find((el) => el.location === location);
+  // Extract and process diagnostics
+  const diagnostics = event.result.diagnostics;
+  const locations: string[] = Array.from(
+    new Set(
+      diagnostics.map((d) => d.file).filter((f): f is string => f !== null),
+    ),
+  );
+
+  progress.total += locations.length;
+
+  // Group diagnostics by file and add to failures
+  const diagnosticsByFile: Record<string, IAutoBeRealizeFunctionFailure> = {};
+  diagnostics.forEach((diagnostic) => {
+    const location: string | null = diagnostic.file;
+    if (location === null) return;
 
-    if (func) {
-      failures.push({
+    if (!diagnosticsByFile[location]) {
+      const func = functions.find((f) => f.location === location)!;
+      const failure: IAutoBeRealizeFunctionFailure = {
         function: func,
-        diagnostics,
-      });
+        diagnostics: [],
+      };
+      diagnosticsByFile[location] = failure;
     }
-  }
+    diagnosticsByFile[location].diagnostics.push(diagnostic);
+  });
+
+  await correct(
+    ctx,
+    locations,
+    scenarios,
+    authorizations,
+    functions,
+    [...failures, ...Object.values(diagnosticsByFile)],
+    progress,
+  );
+
+  return orchestrateRealizeCorrect(
+    ctx,
+    scenarios,
+    authorizations,
+    functions,
+    [...failures, ...Object.values(diagnosticsByFile)],
+    progress,
+    life - 1,
+  );
+}
 
-  await executeCachedBatch(
+async function correct<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  locations: string[],
+  scenarios: IAutoBeRealizeScenarioResult[],
+  authorizations: AutoBeRealizeAuthorization[],
+  functions: AutoBeRealizeFunction[],
+  failures: IAutoBeRealizeFunctionFailure[],
+  progress: AutoBeProgressEventBase,
+): Promise<AutoBeRealizeFunction[]> {
+  return executeCachedBatch(
     locations.map((location) => async (): Promise<AutoBeRealizeFunction> => {
       const scenario = scenarios.find((el) => el.location === location);
       const func = functions.find((el) => el.location === location)!;
@@ -80,34 +103,28 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
         failures.filter((f) => f.function.location === location);
 
       if (ReailzeFunctionFailures.length && scenario) {
-        const correctEvent = await correct(ctx, {
-          totalAuthorizations: authorizations,
-          authorization: scenario.decoratorEvent ?? null,
-          scenario,
-          function: func,
-          failures: ReailzeFunctionFailures,
-          progress: progress,
-        });
-
-        func.content = correctEvent.content;
+        try {
+          const correctEvent = await step(ctx, {
+            totalAuthorizations: authorizations,
+            authorization: scenario.decoratorEvent ?? null,
+            scenario,
+            function: func,
+            failures: ReailzeFunctionFailures,
+            progress: progress,
+          });
+
+          func.content = correctEvent.content;
+        } catch (err) {
+          return func;
+        }
       }
 
       return func;
     }),
   );
-
-  return orchestrateRealizeCorrect(
-    ctx,
-    scenarios,
-    authorizations,
-    functions,
-    failures,
-    progress,
-    life,
-  );
 }
 
-export async function correct<Model extends ILlmSchema.Model>(
+async function step<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
     authorization: AutoBeRealizeAuthorization | null;
@@ -204,8 +221,3 @@ const collection = {
   deepseek: claude,
   "3.1": claude,
 };
-
-interface IProgress {
-  total: number;
-  completed: number;
-}

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

@@ -0,0 +1,104 @@
+import {
+  AutoBeOpenApi,
+  AutoBeRealizeAuthorization,
+  AutoBeTestFile,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
+
+/**
+ * Generates a planning result that defines what kind of function should be
+ * created based on the provided Swagger (OpenAPI) operation.
+ *
+ * This function analyzes the structure of the OpenAPI operation (such as the
+ * path, method, parameters, request/response schema, and descriptions) to
+ * determine the appropriate function name, input/output types, and purpose of
+ * the function.
+ *
+ * The result of this function is passed to the next step in the AutoBE
+ * pipeline, which is responsible for generating the actual implementation
+ * code.
+ *
+ * @author Kakasoo
+ * @param ctx - AutoBE context including model and configuration
+ * @param operation - A single OpenAPI operation object to analyze and plan
+ * @param authorization - Optional authorization configuration
+ * @returns A scenario object containing all structural information needed to
+ *   generate the function
+ */
+export function generateRealizeScenario<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  operation: AutoBeOpenApi.IOperation,
+  authorizations: AutoBeRealizeAuthorization[],
+): IAutoBeRealizeScenarioResult {
+  const authorization = authorizations.find(
+    (el) => el.role.name === operation.authorizationRole,
+  );
+
+  const testFiles: AutoBeTestFile[] =
+    ctx
+      .state()
+      .test?.files.filter(
+        (el) =>
+          el.scenario.endpoint.method === operation.method &&
+          el.scenario.endpoint.path === operation.path,
+      ) ?? [];
+
+  const functionName: string = transformFunctionName(operation);
+
+  return {
+    operation: operation,
+    functionName: functionName,
+    location: `src/providers/${functionName}.ts`,
+    testFiles: testFiles,
+    decoratorEvent: authorization,
+  };
+}
+
+/**
+ * Transforms an OpenAPI operation into a unique function name that will be used
+ * by Realize Write and Realize Correct agents to generate the actual
+ * implementation.
+ *
+ * The generated function name follows camelCase convention and ensures
+ * uniqueness by combining HTTP method with the URL path segments.
+ *
+ * @example
+ *   POST /api/v1/users → postApiV1Users
+ *   GET /users/{userId}/posts → getUsersUserIdPosts
+ *   PUT /users/{user-id}/profile → putUsersUserIdProfile
+ *
+ * @param operation - The OpenAPI operation to transform
+ * @returns A unique function name that will be the actual function name in the
+ *   generated code by Realize Write/Correct agents
+ */
+function transformFunctionName(operation: AutoBeOpenApi.IOperation): string {
+  const functionName = `${operation.method}${operation.path
+    .split("/")
+    .filter(Boolean)
+    .map((segment, index) => {
+      if (segment.startsWith("{") && segment.endsWith("}")) {
+        // {userId} → UserId
+        const paramName = segment.slice(1, -1);
+        return paramName
+          .split("-")
+          .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+          .join("");
+      }
+      // api → Api, v1 → V1
+      const words = segment.split("-");
+      return words
+        .map((word) => {
+          if (index === 0 && words.length === 1) {
+            // First segment without hyphens stays lowercase for first word
+            return word;
+          }
+          return word.charAt(0).toUpperCase() + word.slice(1);
+        })
+        .join("");
+    })
+    .join("")}`;
+  return functionName;
+}

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

@@ -4,32 +4,29 @@ import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../../context/AutoBeContext";
 import { getRealizeWriteImportStatements } from "./getRealizeWriteImportStatements";
 
-export async function replaceImportStatements<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-  props: {
-    operation: AutoBeOpenApi.IOperation;
-    code: string;
-    decoratorType?: string;
-  },
-) {
-  let { operation, code, decoratorType } = props;
-
-  const typeReferences: string[] = Array.from(
-    new Set(
-      [operation.requestBody, operation.responseBody]
-        .filter((el) => el !== null)
-        .map((el) => el.typeName.split(".")[0]!),
-    ),
-  );
-
-  const compiler: IAutoBeCompiler = await ctx.compiler();
-  code = await compiler.typescript.beautify(code);
-  // Remove existing import statements using flexible regex patterns
-  code = code
+/**
+ * Removes all import statements that LLM might have incorrectly added. This
+ * includes standard library imports, auto-injected imports, and any API
+ * structure imports with wrong paths.
+ *
+ * @param code - The code containing imports to remove
+ * @param typeReferences - List of type names to specifically remove
+ * @param decoratorType - Optional decorator type to remove
+ * @returns Code with all imports removed
+ */
+function removeAllImports(
+  code: string,
+  typeReferences: string[],
+  decoratorType?: string,
+): string {
+  // Remove standard library and auto-injected imports
+  let cleanedCode = code
+    // MyGlobal - often with wrong path
     .replace(
       /import\s*{\s*MyGlobal\s*}\s*from\s*["']\.\.\/MyGlobal["']\s*;?\s*/gm,
       "",
     )
+    // typia - various import patterns
     .replace(
       /import\s+typia\s*,\s*{\s*tags\s*}\s*from\s*["']typia["']\s*;?\s*/gm,
       "",
@@ -40,53 +37,84 @@ export async function replaceImportStatements<Model extends ILlmSchema.Model>(
       "",
     )
     .replace(/import\s+typia\s*from\s*["']typia["']\s*;?\s*/gm, "")
+    // Prisma client
     .replace(
       /import\s*{\s*Prisma\s*}\s*from\s*["']@prisma\/client["']\s*;?\s*/gm,
       "",
     )
+    // uuid
     .replace(/import\s*{\s*v4\s*}\s*from\s*["']uuid["']\s*;?\s*/gm, "")
+    // toISOStringSafe utility
     .replace(
       /import\s*{\s*toISOStringSafe\s*}\s*from\s*["']\.\.\/util\/toISOStringSafe["']\s*;?\s*/gm,
       "",
     )
-    // Remove JWT import if it exists (to prevent duplication)
+    // JWT imports (if LLM adds them)
     .replace(/import\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm, "")
     .replace(
       /import\s*\*\s*as\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm,
       "",
     );
 
-  // Remove any existing API structure imports
-  // Pattern 1: ../api/structures path
-  code = code.replace(
+  // Remove API structure imports with wrong paths
+  // Pattern 1: ../api/structures path (LLM often uses this wrong path)
+  cleanedCode = cleanedCode.replace(
     /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']\.\.\/api\/structures\/[^"']+["']\s*;?\s*/gm,
     "",
   );
-  // Pattern 2: @ORGANIZATION/PROJECT-api/lib/structures path
-  code = code.replace(
+  // Pattern 2: @ORGANIZATION/PROJECT-api path (correct path but LLM shouldn't write it)
+  cleanedCode = cleanedCode.replace(
     /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']@ORGANIZATION\/PROJECT-api\/lib\/structures\/[^"']+["']\s*;?\s*/gm,
     "",
   );
 
   // Remove specific type imports that match our typeReferences
   for (const ref of typeReferences) {
-    // Remove any import of this specific type from any path
     const typeImportRegex = new RegExp(
       `import\\s*(?:type\\s*)?{\\s*${ref}\\s*}\\s*from\\s*["'][^"']+["']\\s*;?\\s*`,
       "gm",
     );
-    code = code.replace(typeImportRegex, "");
+    cleanedCode = cleanedCode.replace(typeImportRegex, "");
   }
 
-  // Remove any existing decoratorType imports if LLM mistakenly added them
+  // Remove decorator type imports if LLM mistakenly added them
   if (decoratorType) {
     const decoratorTypeRegex = new RegExp(
       `import\\s*(?:type\\s*)?{\\s*${decoratorType}\\s*}\\s*from\\s*["']\\.\\.\/decorators\/payload\/${decoratorType}["']\\s*;?\\s*`,
       "gm",
     );
-    code = code.replace(decoratorTypeRegex, "");
+    cleanedCode = cleanedCode.replace(decoratorTypeRegex, "");
   }
 
+  return cleanedCode;
+}
+
+export async function replaceImportStatements<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    operation: AutoBeOpenApi.IOperation;
+    code: string;
+    decoratorType?: string;
+  },
+) {
+  let { operation, code, decoratorType } = props;
+
+  // Extract type references from operation
+  const typeReferences: string[] = Array.from(
+    new Set(
+      [operation.requestBody, operation.responseBody]
+        .filter((el) => el !== null)
+        .map((el) => el.typeName.split(".")[0]!),
+    ),
+  );
+
+  // Beautify code first for consistent formatting
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+  code = await compiler.typescript.beautify(code);
+
+  // Remove all LLM-generated imports
+  code = removeAllImports(code, typeReferences, decoratorType);
+
   // Build the standard imports
   const imports = getRealizeWriteImportStatements(operation);
 

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

@@ -1,7 +1,7 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { StringUtil } from "@autobe/utils";
 import { ILlmSchema } from "@samchon/openapi";
-import { v4, v7 } from "uuid";
+import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../../context/AutoBeContext";
@@ -33,12 +33,13 @@ export const transformTestCorrectHistories = async <
     },
     previous.at(-1)!,
     ...failures.map(
-      (f) =>
+      (f, i, array) =>
         ({
-          id: v4(),
+          id: v7(),
           created_at: new Date().toISOString(),
           type: "assistantMessage",
           text: StringUtil.trim`
+            # ${i === array.length - 1 ? "Latest Failure" : "Previous Failure"}
             ## Generated TypeScript Code
 
             \`\`\`typescript

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

@@ -0,0 +1,39 @@
+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 { IAutoBeTestFunction } from "../structures/IAutoBeTestFunction";
+
+export const transformTestCorrectInvalidRequestHistories = (
+  func: IAutoBeTestFunction,
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => [
+  {
+    id: v7(),
+    created_at: new Date().toISOString(),
+    type: "systemMessage",
+    text: AutoBeSystemPromptConstant.TEST_CORRECT_INVALID_REQUEST,
+  },
+  {
+    id: v7(),
+    created_at: new Date().toISOString(),
+    type: "assistantMessage",
+    text: StringUtil.trim`
+        ## TypeScript Code
+        
+        \`\`\`typescript
+        ${func.script}
+        \`\`\`
+
+        ## Compile Errors
+
+        \`\`\`json
+        ${JSON.stringify(diagnostics)}
+        \`\`\`
+      `,
+  },
+];

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

@@ -6,20 +6,36 @@ import { v7 } from "uuid";
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
 import { IAutoBeTestScenarioAuthorizationRole } from "../structures/IAutoBeTestScenarioAuthorizationRole";
+import { getReferenceIds } from "../utils/getReferenceIds";
 
 export const transformTestScenarioHistories = (
   state: AutoBeState,
-  entire: AutoBeOpenApi.IOperation[],
+  document: AutoBeOpenApi.IDocument,
   include: AutoBeOpenApi.IOperation[],
   exclude: Pick<AutoBeOpenApi.IOperation, "method" | "path">[],
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
+  interface IRelationship {
+    endpoint: AutoBeOpenApi.IEndpoint;
+    ids: string[];
+  }
   const authorizations: AutoBeInterfaceAuthorization[] =
     state.interface?.authorizations ?? [];
-
   const authorizationRoles: Map<string, IAutoBeTestScenarioAuthorizationRole> =
     new Map();
+  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);
 
   for (const authorization of authorizations) {
     for (const op of authorization.operations) {
@@ -50,27 +66,22 @@ export const transformTestScenarioHistories = (
       created_at: new Date().toISOString(),
       type: "assistantMessage",
       text: StringUtil.trim`
-        # Operations
+        # API Operations
+
+        Below are the complete API operations.
+        Use this information to understand capabilities and dependency relationships.
+        Generate scenarios only for endpoints listed in "Included in Test Plan".
+        Other operations may be referenced as dependencies only.
 
-        Below are the full operations. Please refer to this.
-        Your role is to draft all test cases for each given Operation.
-        It is also permissible to write multiple test codes on a single endpoint.
-        However, rather than meaningless tests, business logic tests should be written and an E2E test situation should be assumed.
+        You may write multiple scenarios for a single included endpoint.
+        Focus on business-logic-oriented E2E flows rather than trivial CRUD.
 
-        Please carefully analyze each operation to identify all dependencies required for testing.
-        For example, if you want to test liking and then deleting a post,
-        you might think to test post creation, liking, and unlike operations.
-        However, even if not explicitly mentioned, user registration or login are essential prerequisites.
+        Please analyze the operations to identify all dependencies required for testing.
         Pay close attention to IDs and related values in the API,
         and ensure you identify all dependencies between endpoints.
 
         \`\`\`json
-        ${JSON.stringify(
-          entire.map((el) => ({
-            ...el,
-            specification: undefined,
-          })),
-        )}
+        ${JSON.stringify({ operations: document.operations })}
         \`\`\`
       `,
     } satisfies IAgenticaHistoryJson.IAssistantMessage,
@@ -86,11 +97,16 @@ export const transformTestScenarioHistories = (
         When testing endpoints that require authentication, ensure you include the corresponding 
         join/login operations in your test scenario to establish proper authentication context.
 
+        Generate test scenarios only for these included endpoints. Do not create scenarios for excluded endpoints. Operations not listed here may be used only as dependencies.
+
         ${include
           .map((el, i) => {
             const roles = Array.from(authorizationRoles.values()).filter(
               (role) => role.name === el.authorizationRole,
             );
+
+            const requiredIds = getReferenceIds({ document, operation: el });
+
             return StringUtil.trim`
               ## ${i + 1}. ${el.method.toUpperCase()} ${el.path}
 
@@ -108,6 +124,14 @@ export const transformTestScenarioHistories = (
                       .join("\n")
                   : "- None"
               }
+
+              Required IDs:
+              
+              - ${
+                requiredIds.length > 0
+                  ? requiredIds.map((id) => `\`${id}\``).join(", ")
+                  : "None"
+              }
             `;
           })
           .join("\n")}
@@ -123,5 +147,39 @@ export const transformTestScenarioHistories = (
           .join("\n")}
       `,
     } satisfies IAgenticaHistoryJson.IAssistantMessage,
+    {
+      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/histories/transformTestValidateEvent.ts

@@ -0,0 +1,14 @@
+import { AutoBeTestValidateEvent } from "@autobe/interface";
+
+import { IAutoBeTestFunction } from "../structures/IAutoBeTestFunction";
+import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
+
+export const transformTestValidateEvent = (
+  event: AutoBeTestValidateEvent,
+  artifacts: IAutoBeTestScenarioArtifacts,
+): IAutoBeTestFunction => ({
+  scenario: event.file.scenario,
+  artifacts,
+  location: event.file.location,
+  script: event.file.content,
+});