@autobe/agent 0.24.1 → 0.25.0

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

@@ -0,0 +1,45 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+
+interface IFailure {
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[];
+  script: string;
+}
+
+export const transformRealizeCorrectCastingHistories = (
+  failures: IFailure[],
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_CORRECT_CASTING,
+    },
+    ...failures.map(
+      (f, i, array) =>
+        ({
+          id: v7(),
+          created_at: new Date().toISOString(),
+          type: "assistantMessage",
+          text: StringUtil.trim`
+          # ${i === array.length - 1 ? "Latest Failure" : "Previous Failure"}
+          ## Generated TypeScript Code
+          \`\`\`typescript
+          ${f.script}
+          \`\`\`
+          ## Compile Errors
+          \`\`\`json
+          ${JSON.stringify(f.diagnostics)}
+          \`\`\`
+        `,
+        }) satisfies IAgenticaHistoryJson.IAssistantMessage,
+    ),
+  ];
+};

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

@@ -23,7 +23,9 @@ export async function compileRealizeFiles<Model extends ILlmSchema.Model>(
   );
   const compiler: IAutoBeCompiler = await ctx.compiler();
   const templateFiles: Record<string, string> =
-    await compiler.realize.getTemplate();
+    await compiler.realize.getTemplate({
+      dbms: "sqlite",
+    });
   const nodeModules: Record<string, string> =
     prisma?.type === "success" ? prisma.nodeModules : {};
 

package/src/orchestrate/realize/orchestRateRealizeCorrectCasting.ts

@@ -14,8 +14,8 @@ import { v7 } from "uuid";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformCommonCorrectCastingHistories } from "../common/histories/transformCommonCorrectCastingHistories";
 import { IAutoBeCommonCorrectCastingApplication } from "../common/structures/IAutoBeCommonCorrectCastingApplication";
+import { transformRealizeCorrectCastingHistories } from "./histories/transformRealizeCorrectCastingHistories";
 import { compileRealizeFiles } from "./internal/compileRealizeFiles";
 
 /** Result of attempting to correct a single function */
@@ -94,6 +94,12 @@ const correct = async <Model extends ILlmSchema.Model>(
   const locations: string[] = diagnose(event).filter((l) =>
     functions.map((f) => f.location).includes(l),
   );
+  
+  // If no locations to correct, return original functions
+  if (locations.length === 0) {
+    return functions;
+  }
+  
   progress.total += locations.length;
 
   const converted: CorrectionResult[] = await executeCachedBatch(
@@ -110,7 +116,7 @@ const correct = async <Model extends ILlmSchema.Model>(
 
       const { tokenUsage } = await ctx.conversate({
         source: "realizeCorrect",
-        histories: transformCommonCorrectCastingHistories([
+        histories: transformRealizeCorrectCastingHistories([
           {
             script: func.content,
             diagnostics: failures.filter((d) => d.file === location),
@@ -166,10 +172,24 @@ const correct = async <Model extends ILlmSchema.Model>(
 
   const newValidate: AutoBeRealizeValidateEvent = await compileRealizeFiles(
     ctx,
-    { authorizations, functions: converted.map((c) => c.func) },
+    {
+      authorizations,
+      functions: converted.map((c) => c.func),
+    },
   );
 
-  if (newValidate.result.type === "success") {
+  const newResult: IAutoBeTypeScriptCompileResult = newValidate.result;
+  if (newResult.type === "success") {
+    return converted.map((c) => c.func);
+  } else if (newResult.type === "exception") {
+    // Compilation exception, return current functions. because retrying won't help.
+    return functions;
+  }
+
+  if (
+    newResult.diagnostics.every((d) => !d.file?.startsWith("src/providers"))
+  ) {
+    // No diagnostics related to provider functions, stop correcting
     return converted.map((c) => c.func);
   }
 
@@ -190,9 +210,7 @@ const correct = async <Model extends ILlmSchema.Model>(
   const failedLocations: string[] = failed.map((f) => f.location);
   const allDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[] = [
     ...failures,
-    ...(newValidate.result.type === "failure"
-      ? newValidate.result.diagnostics
-      : []),
+    ...(newResult.type === "failure" ? newResult.diagnostics : []),
   ];
   const relevantDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[] =
     filterRelevantDiagnostics(allDiagnostics, failedLocations);
@@ -208,7 +226,11 @@ const correct = async <Model extends ILlmSchema.Model>(
     life - 1,
   );
 
-  return [...success, ...ignored, ...retriedFunctions];
+  // Get functions that were not modified (not in converted array)
+  const convertedLocations = converted.map(c => c.func.location);
+  const unchanged = functions.filter(f => !convertedLocations.includes(f.location));
+
+  return [...success, ...ignored, ...retriedFunctions, ...unchanged];
 };
 
 /**

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -19,9 +19,7 @@ import { compileRealizeFiles } from "./internal/compileRealizeFiles";
 import { orchestrateRealizeCorrectCasting } from "./orchestRateRealizeCorrectCasting";
 import { orchestrateRealizeAuthorization } from "./orchestrateRealizeAuthorization";
 import { orchestrateRealizeCorrect } from "./orchestrateRealizeCorrect";
-import { orchestrateRealizeCorrectDate } from "./orchestrateRealizeCorrectDate";
 import { orchestrateRealizeWrite } from "./orchestrateRealizeWrite";
-import { IAutoBeRealizeFunctionFailure } from "./structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 import { generateRealizeScenario } from "./utils/generateRealizeScenario";
 
@@ -53,7 +51,7 @@ export const orchestrateRealize =
       type: "realizeStart",
       id: v7(),
       created_at: start.toISOString(),
-      reason: props.reason,
+      reason: props.instruction,
       step: ctx.state().test?.step ?? 0,
     });
 
@@ -70,22 +68,31 @@ export const orchestrateRealize =
       total: scenarios.length,
       completed: 0,
     };
-    const writeEvents: AutoBeRealizeWriteEvent[] = await executeCachedBatch(
-      scenarios.map((scenario) => async (promptCacheKey) => {
-        const code = await orchestrateRealizeWrite(ctx, {
-          totalAuthorizations: authorizations,
-          authorization: scenario.decoratorEvent ?? null,
-          scenario,
-          progress: writeProgress,
-          promptCacheKey,
-        });
-        return code;
-      }),
-    );
+    const writeEvents: (AutoBeRealizeWriteEvent | null)[] =
+      await executeCachedBatch(
+        scenarios.map((scenario) => async (promptCacheKey) => {
+          const props = {
+            totalAuthorizations: authorizations,
+            authorization: scenario.decoratorEvent ?? null,
+            scenario,
+            progress: writeProgress,
+            promptCacheKey,
+          };
+
+          const code: AutoBeRealizeWriteEvent | null =
+            await orchestrateRealizeWrite(ctx, props).catch(() => {
+              return orchestrateRealizeWrite(ctx, props).catch(() => null);
+            });
+
+          return code;
+        }),
+      );
 
     const functions: AutoBeRealizeFunction[] = Object.entries(
       Object.fromEntries(
-        writeEvents.map((event) => [event.location, event.content]),
+        writeEvents
+          .filter((w) => w !== null)
+          .map((event) => [event.location, event.content]),
       ),
     ).map(([location, content]) => {
       const scenario = scenarios.find((el) => el.location === location)!;
@@ -100,38 +107,27 @@ export const orchestrateRealize =
       };
     });
 
-    const reviewProgress = {
+    const reviewProgress: AutoBeProgressEventBase = {
       total: writeEvents.length,
       completed: writeEvents.length,
     };
 
-    const converted: AutoBeRealizeFunction[] =
+    const totalCorrected: AutoBeRealizeFunction[] =
       await orchestrateRealizeCorrectCasting(
         ctx,
         authorizations,
         functions,
         reviewProgress,
-        parseInt((ctx.retry / 2).toString()),
-      );
-
-    const correctedDate: AutoBeRealizeFunction[] =
-      await orchestrateRealizeCorrectDate(
-        ctx,
-        authorizations,
-        converted,
-        reviewProgress,
-        parseInt((ctx.retry / 2).toString()),
-      );
-
-    const totalCorrected: AutoBeRealizeFunction[] =
-      await orchestrateRealizeCorrect(
-        ctx,
-        scenarios,
-        authorizations,
-        correctedDate,
-        [] satisfies IAutoBeRealizeFunctionFailure[],
-        reviewProgress,
-      );
+      ).then(async (res) => {
+        return orchestrateRealizeCorrect(
+          ctx,
+          scenarios,
+          authorizations,
+          res,
+          [],
+          reviewProgress,
+        );
+      });
 
     const compiler: IAutoBeCompiler = await ctx.compiler();
     const controllers: Record<string, string> =
@@ -150,7 +146,7 @@ export const orchestrateRealize =
       type: "realizeComplete",
       id: v7(),
       created_at: new Date().toISOString(),
-      functions,
+      functions: totalCorrected,
       authorizations,
       controllers,
       compiled: result,

package/src/orchestrate/realize/orchestrateRealizeAuthorization.ts

@@ -41,7 +41,11 @@ export async function orchestrateRealizeAuthorization<
     total: roles.length,
     completed: 0,
   };
-  const templateFiles = await (await ctx.compiler()).realize.getTemplate();
+  const templateFiles = await (
+    await ctx.compiler()
+  ).realize.getTemplate({
+    dbms: "sqlite",
+  });
   const authorizations: AutoBeRealizeAuthorization[] = await executeCachedBatch(
     roles.map(
       (role) => (promptCacheKey) =>

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -35,12 +35,19 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
     authorizations,
     functions,
   });
-
   if (event.result.type !== "failure") return functions;
   else if (life < 0) return functions;
 
   // Extract and process diagnostics
   const diagnostics = event.result.diagnostics;
+
+  if (
+    event.result.diagnostics.every((d) => !d.file?.startsWith("src/providers"))
+  ) {
+    // No diagnostics related to provider functions, stop correcting
+    return functions;
+  }
+
   const locations: string[] = Array.from(
     new Set(
       diagnostics
@@ -116,7 +123,11 @@ async function correct<Model extends ILlmSchema.Model>(
   failures: IAutoBeRealizeFunctionFailure[],
   progress: AutoBeProgressEventBase,
 ): Promise<AutoBeRealizeFunction[]> {
-  const result: AutoBeRealizeFunction[] = await executeCachedBatch(
+  if (locations.length === 0) {
+    return 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);
@@ -130,16 +141,22 @@ async function correct<Model extends ILlmSchema.Model>(
 
       if (RealizeFunctionFailures.length && scenario) {
         try {
-          const correctEvent = await step(ctx, {
-            totalAuthorizations: authorizations,
-            authorization: scenario.decoratorEvent ?? null,
-            scenario,
-            function: func,
-            failures: RealizeFunctionFailures,
-            progress: progress,
-          });
-
-          return { ...func, content: correctEvent.content };
+          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;
         }
@@ -149,7 +166,11 @@ async function correct<Model extends ILlmSchema.Model>(
     }),
   );
 
-  return result;
+  // 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);
 }
 
 async function step<Model extends ILlmSchema.Model>(
@@ -162,7 +183,7 @@ async function step<Model extends ILlmSchema.Model>(
     failures: IAutoBeRealizeFunctionFailure[];
     progress: AutoBeProgressEventBase;
   },
-): Promise<AutoBeRealizeCorrectEvent> {
+): Promise<AutoBeRealizeCorrectEvent | null> {
   const pointer: IPointer<IAutoBeRealizeCorrectApplication.IProps | null> = {
     value: null,
   };
@@ -193,8 +214,9 @@ async function step<Model extends ILlmSchema.Model>(
     `,
   });
 
-  if (pointer.value === null)
-    throw new Error("Failed to correct implementation code.");
+  if (pointer.value === null) {
+    return null;
+  }
 
   pointer.value.revise.final = await replaceImportStatements(ctx, {
     operation: props.scenario.operation,

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

@@ -78,7 +78,7 @@ function transformFunctionName(operation: AutoBeOpenApi.IOperation): string {
   const functionName = `${operation.method}${operation.path
     .split("/")
     .filter(Boolean)
-    .map((segment, index) => {
+    .map((segment) => {
       if (segment.startsWith("{") && segment.endsWith("}")) {
         // {userId} → UserId
         const paramName = segment.slice(1, -1);
@@ -91,10 +91,6 @@ function transformFunctionName(operation: AutoBeOpenApi.IOperation): string {
       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("");

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

@@ -19,6 +19,7 @@ export function getRealizeWriteImportStatements(
     'import { Prisma } from "@prisma/client";',
     'import { v4 } from "uuid";',
     'import { toISOStringSafe } from "../util/toISOStringSafe"',
+    'import { HttpException } from "@nestjs/common";',
     ...typeReferences.map(
       (ref) =>
         `import { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,

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

@@ -54,6 +54,11 @@ function removeAllImports(
     .replace(
       /import\s*\*\s*as\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm,
       "",
+    )
+    // NestJS HttpException
+    .replace(
+      /import\s*{\s*HttpException\s*}\s*from\s*["']@nestjs\/common["']\s*;?\s*/gm,
+      "",
     );
 
   // Remove API structure imports with wrong paths

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

@@ -13,8 +13,11 @@ export const transformTestCorrectHistories = async <
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  func: IAutoBeTestFunction,
-  failures: IAutoBeTestFunctionFailure[],
+  props: {
+    instruction: string;
+    function: IAutoBeTestFunction;
+    failures: IAutoBeTestFunctionFailure[];
+  },
 ): Promise<
   Array<
     IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
@@ -22,7 +25,11 @@ export const transformTestCorrectHistories = async <
 > => {
   const previous: Array<
     IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-  > = await transformTestWriteHistories(ctx, func.scenario, func.artifacts);
+  > = await transformTestWriteHistories(ctx, {
+    instruction: props.instruction,
+    scenario: props.function.scenario,
+    artifacts: props.function.artifacts,
+  });
   return [
     ...previous.slice(0, -1),
     {
@@ -32,21 +39,21 @@ export const transformTestCorrectHistories = async <
       text: AutoBeSystemPromptConstant.TEST_CORRECT,
     },
     previous.at(-1)!,
-    ...failures.map(
+    ...props.failures.map(
       (f, i, array) =>
         ({
           id: v7(),
           created_at: new Date().toISOString(),
           type: "assistantMessage",
           text: StringUtil.trim`
-            # ${i === array.length - 1 ? "Latest Failure" : "Previous Failure"}
-            ## Generated TypeScript Code
+            ## ${i === array.length - 1 ? "Latest Failure" : "Previous Failure"}
+            ### Generated TypeScript Code
 
             \`\`\`typescript
             ${f.function.script}
             \`\`\`
 
-            ## Compile Errors
+            ### Compile Errors
 
             Fix the compilation error in the provided code.
 

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

@@ -8,12 +8,13 @@ import { AutoBeState } from "../../../context/AutoBeState";
 import { IAutoBeTestScenarioAuthorizationRole } from "../structures/IAutoBeTestScenarioAuthorizationRole";
 import { getReferenceIds } from "../utils/getReferenceIds";
 
-export const transformTestScenarioHistories = (
-  state: AutoBeState,
-  document: AutoBeOpenApi.IDocument,
-  include: AutoBeOpenApi.IOperation[],
-  exclude: Pick<AutoBeOpenApi.IOperation, "method" | "path">[],
-): Array<
+export const transformTestScenarioHistories = (props: {
+  state: AutoBeState;
+  document: AutoBeOpenApi.IDocument;
+  include: AutoBeOpenApi.IOperation[];
+  exclude: Pick<AutoBeOpenApi.IOperation, "method" | "path">[];
+  instruction: string;
+}): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
   interface IRelationship {
@@ -21,18 +22,18 @@ export const transformTestScenarioHistories = (
     ids: string[];
   }
   const authorizations: AutoBeInterfaceAuthorization[] =
-    state.interface?.authorizations ?? [];
+    props.state.interface?.authorizations ?? [];
   const authorizationRoles: Map<string, IAutoBeTestScenarioAuthorizationRole> =
     new Map();
-  const relationships: IRelationship[] = document.operations
-    .map((o) => ({
+  const relationships: IRelationship[] = props.document.operations
+    .map((operation) => ({
       endpoint: {
-        method: o.method,
-        path: o.path,
+        method: operation.method,
+        path: operation.path,
       },
       ids: getReferenceIds({
-        document,
-        operation: o,
+        document: props.document,
+        operation,
       }),
     }))
     .filter((v) => v.ids.length !== 0);
@@ -66,7 +67,22 @@ export const transformTestScenarioHistories = (
       created_at: new Date().toISOString(),
       type: "assistantMessage",
       text: StringUtil.trim`
-        # API Operations
+        ## Instructions
+
+        The following e2e-test-specific instructions were extracted by AI from
+        the user's requirements and conversations. These instructions focus
+        exclusively on test-related aspects such as test coverage priorities,
+        specific edge cases to validate, business logic verification strategies,
+        and critical user workflows that must be tested.
+        
+        Apply these instructions when generating test scenarios to ensure the
+        tests align with the user's testing requirements and expectations.
+        If any instructions are not relevant to the target API operations,
+        you may ignore them.
+
+        ${props.instruction}
+
+        ## API Operations
 
         Below are the complete API operations.
         Use this information to understand capabilities and dependency relationships.
@@ -81,16 +97,12 @@ export const transformTestScenarioHistories = (
         and ensure you identify all dependencies between endpoints.
 
         \`\`\`json
-        ${JSON.stringify({ operations: document.operations })}
+        ${JSON.stringify({
+          operations: props.document.operations,
+        })}
         \`\`\`
-      `,
-    } satisfies IAgenticaHistoryJson.IAssistantMessage,
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
-        # Included in Test Plan
+
+        ## Included in Test Plan
 
         Below are the endpoints that have been included in the test plan.
         Each endpoint shows its authentication requirements and related authentication APIs.
@@ -99,14 +111,16 @@ export const transformTestScenarioHistories = (
 
         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
+        ${props.include
           .map((el, i) => {
             const roles = Array.from(authorizationRoles.values()).filter(
               (role) => role.name === el.authorizationRole,
             );
 
-            const requiredIds = getReferenceIds({ document, operation: el });
-
+            const requiredIds = getReferenceIds({
+              document: props.document,
+              operation: el,
+            });
             return StringUtil.trim`
               ## ${i + 1}. ${el.method.toUpperCase()} ${el.path}
 
@@ -136,23 +150,17 @@ export const transformTestScenarioHistories = (
           })
           .join("\n")}
 
-        # Excluded from Test Plan
+        ## Excluded from Test Plan
 
         These are the endpoints that have already been used in test codes generated as part of a plan group.
         These endpoints do not need to be tested again.
         However, it is allowed to reference or depend on these endpoints when writing test codes for other purposes.
 
-        ${exclude
+        ${props.exclude
           .map((el) => `- ${el.method.toUpperCase()}: ${el.path}`)
           .join("\n")}
-      `,
-    } satisfies IAgenticaHistoryJson.IAssistantMessage,
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
-        # Candidate Dependencies
+
+        ## Candidate Dependencies
     
         List of candidate dependencies extracted from path parameters and request bodies.