@autobe/agent 0.22.0 → 0.23.0

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/compile/completeTestCode.ts

@@ -1,28 +1,26 @@
 import { StringUtil } from "@autobe/utils";
+import { ILlmSchema } from "@samchon/openapi";
 
+import { AutoBeContext } from "../../../context/AutoBeContext";
 import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
 import { getTestImportStatements } from "./getTestImportStatements";
 
-export function completeTestCode(
+export const completeTestCode = async <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
   artifacts: IAutoBeTestScenarioArtifacts,
   code: string,
-): string {
+): Promise<string> => {
+  const compiler = await ctx.compiler();
+  code = await compiler.typescript.beautify(code);
   code = code
     .split("\r\n")
     .join("\n")
     .split("\n")
     .filter((str) => str.trim().startsWith("import") === false)
     .join("\n");
-
-  // code = code.replace(/^[ \t]*import\b[\s\S]*?;[ \t]*$/gm, "").trim();
-  // code = code.replace(/^[ \t]*import\b[\s\S]*?;[ \t]*$/gm, "").trim();
-  // code = code.replaceAll(
-  //   'string & Format<"uuid">',
-  //   'string & tags.Format<"uuid">',
-  // );
-  return StringUtil.trim`
+  return await compiler.typescript.beautify(StringUtil.trim`
     ${getTestImportStatements(artifacts.document)}
     
     ${code}
-  `;
-}
+  `);
+};

package/src/orchestrate/test/compile/getTestExternalDeclarations.ts

@@ -18,11 +18,22 @@ const singleton = new Singleton(async (compiler: IAutoBeTestCompiler) => {
     if (content === undefined) throw new Error(`File not found: ${location}`);
     return { [location]: content };
   };
+  const filter = (
+    closure: (key: string) => boolean,
+  ): Record<string, string> => {
+    const entries = Object.entries(records).filter(([key]) => closure(key));
+    return Object.fromEntries(entries);
+  };
   return {
     ...external("node_modules/@nestia/e2e/lib/ArrayUtil.d.ts"),
     ...external("node_modules/@nestia/e2e/lib/RandomGenerator.d.ts"),
     ...external("node_modules/@nestia/e2e/lib/TestValidator.d.ts"),
     ...external("node_modules/@nestia/fetcher/lib/IConnection.d.ts"),
+    ...external("node_modules/@samchon/openapi/lib/http/HttpError.d.ts"),
     ...external("node_modules/typia/lib/module.d.ts"),
+    ...filter(
+      (key) =>
+        key.startsWith("node_modules/typia/lib/tags") && key.endsWith(".d.ts"),
+    ),
   } satisfies Record<string, string>;
 });

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)}
+        \`\`\`
+      `,
+  },
+];