@autobe/agent 0.30.3 → 0.30.4-dev.20260324

package/src/orchestrate/test/experimental/orchestrateTestCorrect.ast

@@ -1,237 +1,237 @@
-import {
-  AgenticaSystemPrompt,
-  IAgenticaController,
-  MicroAgentica,
-} from "@agentica/core";
-import {
-  AutoBeTest,
-  AutoBeTestValidateEvent,
-  IAutoBeTypeScriptCompileResult,
-} from "@autobe/interface";
-import {
-  ILlmApplication,
-  ILlmSchema,
-  OpenApi,
-  OpenApiTypeChecker,
-} from "@samchon/openapi";
-import { IPointer } from "tstl";
-import typia, { IJsonSchemaUnit } from "typia";
-
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { enforceToolCall } from "../../utils/enforceToolCall";
-import { IAutoBeTestWriteResult } from "./structures/IAutoBeTestWriteResult";
-import { transformTestCorrectHistories } from "./transformTestCorrectHistories";
-
-export function orchestrateTestCorrect<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-  results: IAutoBeTestWriteResult[],
-  life: number = 4,
-): Promise<AutoBeTestValidateEvent[]> {
-  return Promise.all(
-    results.map(async (written) => {
-      const event: AutoBeTestValidateEvent = await compile(ctx, written);
-      return predicate(ctx, written, event, life);
-    }),
-  );
-}
-
-async function predicate<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-  written: IAutoBeTestWriteResult,
-  event: AutoBeTestValidateEvent,
-  life: number,
-): Promise<AutoBeTestValidateEvent> {
-  ctx.dispatch(event);
-  return event.result.type === "failure"
-    ? correct(ctx, written, event, life - 1)
-    : event;
-}
-
-async function correct<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-  written: IAutoBeTestWriteResult,
-  event: AutoBeTestValidateEvent,
-  life: number,
-): Promise<AutoBeTestValidateEvent> {
-  if (event.result.type !== "failure") return event;
-  else if (--life <= 0) return event;
-
-  const pointer: IPointer<ICorrectTestFunctionProps | null> = {
-    value: null,
-  };
-  const agentica = new MicroAgentica({
-    model: ctx.model,
-    vendor: { ...ctx.vendor },
-    config: {
-      ...(ctx.config ?? {}),
-      executor: {
-        describe: null,
-      },
-      systemPrompt: {
-        validate: (events) =>
-          [
-            AgenticaSystemPrompt.VALIDATE_REPEATED.replace(
-              "${{HISTORICAL_ERRORS}}",
-              JSON.stringify(events.map((e) => e.result.errors)),
-            ),
-            AutoBeSystemPromptConstant.TEST_VALIDATE.replace(
-              "${{AutoBeTest.IStatement}}",
-              getUnionTypeName(typia.json.schema<AutoBeTest.IStatement>()),
-            ).replace(
-              "${{AutoBeTest.IExpression}}",
-              getUnionTypeName(typia.json.schema<AutoBeTest.IExpression>()),
-            ),
-          ].join("\n\n"),
-      },
-      retry: 4,
-      throw: true,
-    },
-    histories: transformTestCorrectHistories(written, event.result),
-    controllers: [
-      createController({
-        model: ctx.model,
-        build: (next) => {
-          pointer.value = next;
-        },
-      }),
-    ],
-  });
-  enforceToolCall(agentica);
-
-  await agentica
-    .conversate(
-      "Fix the `AutoBeTest.IFunction` data to resolve the compilation error.",
-    )
-    .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
-      ctx.usage().record(tokenUsage, ["test"]);
-    });
-  if (pointer.value === null) throw new Error("Failed to modify test code.");
-  event = await compile(ctx, {
-    ...written,
-    file: {
-      ...written.file,
-      function: pointer.value.function,
-    },
-  });
-  return predicate(ctx, written, event, life);
-}
-
-async function compile<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-  written: IAutoBeTestWriteResult,
-): Promise<AutoBeTestValidateEvent> {
-  const compiled: IAutoBeTypeScriptCompileResult =
-    await ctx.compiler.test.compile({
-      files: {
-        ...written.artifacts.dto,
-        ...written.artifacts.sdk,
-        [written.file.location]: written.file.content,
-      },
-    });
-  return {
-    type: "testValidate",
-    file: written.file,
-    result: compiled,
-    created_at: new Date().toISOString(),
-    step: ctx.state().analyze?.step ?? 0,
-  };
-}
-
-function getUnionTypeName(unit: IJsonSchemaUnit): string {
-  if (OpenApiTypeChecker.isReference(unit.schema) === false) return "unknown";
-
-  const typeName: string = unit.schema.$ref.split("/").pop() ?? "";
-  const schema: OpenApi.IJsonSchema | undefined =
-    unit.components.schemas?.[typeName];
-  if (schema === undefined || OpenApiTypeChecker.isOneOf(schema) === false)
-    return "unknown";
-  return schema.oneOf
-    .filter(OpenApiTypeChecker.isReference)
-    .map((r) => r.$ref.split("/").pop() ?? "")
-    .join(" | ");
-}
-
-function createController<Model extends ILlmSchema.Model>(props: {
-  model: Model;
-  build: (next: ICorrectTestFunctionProps) => void;
-}): IAgenticaController.IClass<Model> {
-  assertSchemaModel(props.model);
-
-  const application: ILlmApplication<Model> = collection[
-    props.model
-  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
-  return {
-    protocol: "class",
-    name: "Modify Test Code",
-    application,
-    execute: {
-      correctTestCode: (next) => {
-        props.build(next);
-      },
-    } satisfies IApplication,
-  };
-}
-
-const claude = typia.llm.application<
-  IApplication,
-  "claude"
->();
-const collection = {
-  chatgpt: typia.llm.application<
-    IApplication,
-    "chatgpt"
-  >(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
-};
-
-interface IApplication {
-  correctTestCode(props: ICorrectTestFunctionProps): void;
-}
-
-interface ICorrectTestFunctionProps {
-  /**
-   * Step 1: Initial self-reflection on the source code without compiler error
-   * context.
-   *
-   * The AI agent analyzes the previously generated test code to identify
-   * potential issues, relying solely on its understanding of TypeScript syntax,
-   * testing patterns, and best practices.
-   *
-   * This encourages the agent to develop independent debugging skills before
-   * being influenced by external error messages.
-   */
-  think_without_compile_error: string;
-
-  /**
-   * Step 2: Re-evaluation of the code with compiler error messages as
-   * additional context.
-   *
-   * After the initial analysis, the AI agent reviews the same code again, this
-   * time incorporating the specific TypeScript compiler error messages.
-   *
-   * This allows the agent to correlate its initial observations with concrete
-   * compilation failures and refine its understanding of what went wrong.
-   */
-  think_again_with_compile_error: string;
-
-  /**
-   * Step 3: Concrete action plan for fixing the identified issues.
-   *
-   * Based on the analysis from steps 1 and 2, the AI agent formulates a
-   * specific, step-by-step solution strategy.
-   *
-   * This should include what changes need to be made, why those changes are
-   * necessary, and how they will resolve the compilation errors while
-   * maintaining the test's intended functionality.
-   */
-  solution: string;
-
-  /** Re-written AST data to fix the compilation error. */
-  function: AutoBeTest.IFunction;
-}
+import {
+  AgenticaSystemPrompt,
+  IAgenticaController,
+  MicroAgentica,
+} from "@agentica/core";
+import {
+  AutoBeTest,
+  AutoBeTestValidateEvent,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import {
+  ILlmApplication,
+  ILlmSchema,
+  OpenApi,
+  OpenApiTypeChecker,
+} from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia, { IJsonSchemaUnit } from "typia";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { enforceToolCall } from "../../utils/enforceToolCall";
+import { IAutoBeTestWriteResult } from "./structures/IAutoBeTestWriteResult";
+import { transformTestCorrectHistories } from "./transformTestCorrectHistories";
+
+export function orchestrateTestCorrect<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  results: IAutoBeTestWriteResult[],
+  life: number = 4,
+): Promise<AutoBeTestValidateEvent[]> {
+  return Promise.all(
+    results.map(async (written) => {
+      const event: AutoBeTestValidateEvent = await compile(ctx, written);
+      return predicate(ctx, written, event, life);
+    }),
+  );
+}
+
+async function predicate<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  written: IAutoBeTestWriteResult,
+  event: AutoBeTestValidateEvent,
+  life: number,
+): Promise<AutoBeTestValidateEvent> {
+  ctx.dispatch(event);
+  return event.result.type === "failure"
+    ? correct(ctx, written, event, life - 1)
+    : event;
+}
+
+async function correct<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  written: IAutoBeTestWriteResult,
+  event: AutoBeTestValidateEvent,
+  life: number,
+): Promise<AutoBeTestValidateEvent> {
+  if (event.result.type !== "failure") return event;
+  else if (--life <= 0) return event;
+
+  const pointer: IPointer<ICorrectTestFunctionProps | null> = {
+    value: null,
+  };
+  const agentica = new MicroAgentica({
+    model: ctx.model,
+    vendor: { ...ctx.vendor },
+    config: {
+      ...(ctx.config ?? {}),
+      executor: {
+        describe: null,
+      },
+      systemPrompt: {
+        validate: (events) =>
+          [
+            AgenticaSystemPrompt.VALIDATE_REPEATED.replace(
+              "${{HISTORICAL_ERRORS}}",
+              JSON.stringify(events.map((e) => e.result.errors)),
+            ),
+            AutoBeSystemPromptConstant.TEST_VALIDATE.replace(
+              "${{AutoBeTest.IStatement}}",
+              getUnionTypeName(typia.json.schema<AutoBeTest.IStatement>()),
+            ).replace(
+              "${{AutoBeTest.IExpression}}",
+              getUnionTypeName(typia.json.schema<AutoBeTest.IExpression>()),
+            ),
+          ].join("\n\n"),
+      },
+      retry: 4,
+      throw: true,
+    },
+    histories: transformTestCorrectHistories(written, event.result),
+    controllers: [
+      createController({
+        model: ctx.model,
+        build: (next) => {
+          pointer.value = next;
+        },
+      }),
+    ],
+  });
+  enforceToolCall(agentica);
+
+  await agentica
+    .conversate(
+      "Fix the `AutoBeTest.IFunction` data to resolve the compilation error.",
+    )
+    .finally(() => {
+      const tokenUsage = agentica.getTokenUsage();
+      ctx.usage().record(tokenUsage, ["test"]);
+    });
+  if (pointer.value === null) throw new Error("Failed to modify test code.");
+  event = await compile(ctx, {
+    ...written,
+    file: {
+      ...written.file,
+      function: pointer.value.function,
+    },
+  });
+  return predicate(ctx, written, event, life);
+}
+
+async function compile<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  written: IAutoBeTestWriteResult,
+): Promise<AutoBeTestValidateEvent> {
+  const compiled: IAutoBeTypeScriptCompileResult =
+    await ctx.compiler.test.compile({
+      files: {
+        ...written.artifacts.dto,
+        ...written.artifacts.sdk,
+        [written.file.location]: written.file.content,
+      },
+    });
+  return {
+    type: "testValidate",
+    file: written.file,
+    result: compiled,
+    created_at: new Date().toISOString(),
+    step: ctx.state().analyze?.step ?? 0,
+  };
+}
+
+function getUnionTypeName(unit: IJsonSchemaUnit): string {
+  if (OpenApiTypeChecker.isReference(unit.schema) === false) return "unknown";
+
+  const typeName: string = unit.schema.$ref.split("/").pop() ?? "";
+  const schema: OpenApi.IJsonSchema | undefined =
+    unit.components.schemas?.[typeName];
+  if (schema === undefined || OpenApiTypeChecker.isOneOf(schema) === false)
+    return "unknown";
+  return schema.oneOf
+    .filter(OpenApiTypeChecker.isReference)
+    .map((r) => r.$ref.split("/").pop() ?? "")
+    .join(" | ");
+}
+
+function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (next: ICorrectTestFunctionProps) => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "Modify Test Code",
+    application,
+    execute: {
+      correctTestCode: (next) => {
+        props.build(next);
+      },
+    } satisfies IApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IApplication,
+  "claude"
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    IApplication,
+    "chatgpt"
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};
+
+interface IApplication {
+  correctTestCode(props: ICorrectTestFunctionProps): void;
+}
+
+interface ICorrectTestFunctionProps {
+  /**
+   * Step 1: Initial self-reflection on the source code without compiler error
+   * context.
+   *
+   * The AI agent analyzes the previously generated test code to identify
+   * potential issues, relying solely on its understanding of TypeScript syntax,
+   * testing patterns, and best practices.
+   *
+   * This encourages the agent to develop independent debugging skills before
+   * being influenced by external error messages.
+   */
+  think_without_compile_error: string;
+
+  /**
+   * Step 2: Re-evaluation of the code with compiler error messages as
+   * additional context.
+   *
+   * After the initial analysis, the AI agent reviews the same code again, this
+   * time incorporating the specific TypeScript compiler error messages.
+   *
+   * This allows the agent to correlate its initial observations with concrete
+   * compilation failures and refine its understanding of what went wrong.
+   */
+  think_again_with_compile_error: string;
+
+  /**
+   * Step 3: Concrete action plan for fixing the identified issues.
+   *
+   * Based on the analysis from steps 1 and 2, the AI agent formulates a
+   * specific, step-by-step solution strategy.
+   *
+   * This should include what changes need to be made, why those changes are
+   * necessary, and how they will resolve the compilation errors while
+   * maintaining the test's intended functionality.
+   */
+  solution: string;
+
+  /** Re-written AST data to fix the compilation error. */
+  function: AutoBeTest.IFunction;
+}