@autobe/agent 0.14.5 → 0.15.0

package/src/orchestrate/realize/{transformRealizeDecoratorCorrectHistories.ts → transformRealizeAuthorizationCorrectHistories.ts}

@@ -8,9 +8,8 @@ import { v4 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeRealizeDecoratorApplication } from "./structures/IAutoBeRealizeDecoratorApplication";
 
-export const transformRealizeDecoratorCorrectHistories = (
+export const transformRealizeAuthorizationCorrectHistories = (
   ctx: AutoBeContext<ILlmSchema.Model>,
   auth: AutoBeRealizeAuthorization,
   templateFiles: Record<string, string>,
@@ -23,7 +22,13 @@ export const transformRealizeDecoratorCorrectHistories = (
       id: v4(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
-      text: AutoBeSystemPromptConstant.REALIZE_DECORATOR_CORRECT,
+      text: AutoBeSystemPromptConstant.REALIZE_AUTHORIZATION,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_AUTHORIZATION_CORRECT,
     },
     {
       id: v4(),
@@ -36,18 +41,21 @@ export const transformRealizeDecoratorCorrectHistories = (
         `${JSON.stringify(
           {
             provider: {
+              location: auth.provider.location,
               name: auth.provider.name,
-              code: auth.provider.content,
+              content: auth.provider.content,
             },
             decorator: {
+              location: auth.decorator.location,
               name: auth.decorator.name,
-              code: auth.decorator.content,
+              content: auth.decorator.content,
             },
             payload: {
+              location: auth.payload.location,
               name: auth.payload.name,
-              code: auth.payload.content,
+              content: auth.payload.content,
             },
-          } satisfies IAutoBeRealizeDecoratorApplication.IProps,
+          } satisfies Omit<AutoBeRealizeAuthorization, "role">,
           null,
           2,
         )}`,

package/src/orchestrate/realize/transformRealizeCoderHistories.ts

@@ -101,12 +101,12 @@ export const transformRealizeCoderHistories = (
             `- Decorator implementation: decorators/${props.decoratorEvent.decorator.name}.ts`,
             `  - NestJS parameter decorator`,
             `  - When importing from providers folder, use: '../decorators/${props.decoratorEvent.decorator.name}'`,
-            `- Authentication provider: authentications/${props.decoratorEvent.provider.name}.ts`,
+            `- Authentication provider: decorators/${props.decoratorEvent.provider.name}.ts`,
             `  - Contains JWT validation, role checking, and authorization logic`,
-            `  - When importing from providers folder, use: '../authentications/${props.decoratorEvent.provider.name}'`,
-            `- Type definition: authentications/types/${props.decoratorEvent.payload.name}.ts`,
+            `  - When importing from providers folder, use: '../decorators/${props.decoratorEvent.provider.name}'`,
+            `- Type definition: decorators/payload/${props.decoratorEvent.payload.name}.ts`,
             `  - TypeScript interface for authenticated user payload`,
-            `  - When importing from providers folder, use: '../authentications/types/${props.decoratorEvent.payload.name}'`,
+            `  - When importing from providers folder, use: '../decorators/payload/${props.decoratorEvent.payload.name}'`,
           ].join("\n")
         : "",
     },

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

@@ -0,0 +1,12 @@
+export namespace InternalFileSystem {
+  /**
+   * Get template files for all of realize agents
+   *
+   * @returns Template file paths
+   */
+  export const DEFAULT = [
+    "src/providers/authorize/jwtAuthorize.ts",
+    "src/MyGlobal.ts",
+    "src/util/toISOStringSafe.ts",
+  ];
+}

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

@@ -0,0 +1,4 @@
+export namespace RealizeFileSystem {
+  export const providerPath = (filename: string): string =>
+    `src/providers/${filename}.ts`;
+}

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

@@ -38,7 +38,7 @@ export function replaceImportStatements<Model extends ILlmSchema.Model>(
     // Remove any existing decoratorType imports if LLM mistakenly added them
     if (decoratorType) {
       const decoratorTypeRegex = new RegExp(
-        `import\\s*{\\s*${decoratorType}\\s*}\\s*from\\s*["']\\.\\.\/authentications\/types\/${decoratorType}["']\\s*;?\\s*`,
+        `import\\s*{\\s*${decoratorType}\\s*}\\s*from\\s*["']\\.\\.\/decorators\/payload\/${decoratorType}["']\\s*;?\\s*`,
         "gm",
       );
       code = code.replace(decoratorTypeRegex, "");
@@ -56,7 +56,7 @@ export function replaceImportStatements<Model extends ILlmSchema.Model>(
     // Only add decoratorType import if it exists
     if (decoratorType) {
       imports.push(
-        `import { ${decoratorType} } from "../authentications/types/${decoratorType}"`,
+        `import { ${decoratorType} } from "../decorators/payload/${decoratorType}"`,
       );
     }
 

package/src/orchestrate/realize/writeCodeUntilCompilePassed.ts

@@ -5,15 +5,15 @@ import {
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
-import { readFile } from "fs/promises";
-import path from "path";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
+import { arrayToRecord } from "../../utils/arrayToRecord";
 import { pipe } from "./RealizePipe";
 import { orchestrateRealizeCoder } from "./orchestrateRealizeCoder";
 import { orchestrateRealizePlanner } from "./orchestrateRealizePlanner";
 import { IAutoBeRealizeCompile } from "./structures/IAutoBeRealizeCompile";
 import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
+import { RealizeFileSystem } from "./utils/ProviderFileSystem";
 
 export async function writeCodeUntilCompilePassed<
   Model extends ILlmSchema.Model,
@@ -23,26 +23,20 @@ export async function writeCodeUntilCompilePassed<
   authorizations: AutoBeRealizeAuthorization[],
   retry: number,
 ): Promise<AutoBeRealizeFunction[]> {
-  const payloads = authorizations
-    .map((el) => {
-      return {
-        [el.payload.location]: el.payload.content,
-      };
-    })
-    .reduce<Record<string, string>>((acc, cur) => Object.assign(acc, cur), {});
-
-  const files = Object.entries(await ctx.files({ dbms: "postgres" }))
-    .filter(([key]) => {
-      return key.startsWith("src");
-    })
-    .reduce(
-      (acc, [filename, content]) => Object.assign(acc, { [filename]: content }),
-      {},
-    );
+  const payloads = arrayToRecord(
+    authorizations.map((el) => el.payload),
+    "location",
+    "content",
+  );
+
+  const files = arrayToRecord(
+    Object.entries(await ctx.files({ dbms: "postgres" })).filter(([key]) =>
+      key.startsWith("src"),
+    ),
+  );
 
-  const templateFiles = ["src/MyGlobal.ts", "src/util/toISOStringSafe.ts"];
   const entireCodes: IAutoBeRealizeCompile.FileContentMap = {
-    ...(await loadTemplateFiles(templateFiles)),
+    ...(await loadTemplateFiles(ctx)),
   };
 
   let diagnostics: IAutoBeRealizeCompile.CompileDiagnostics = {
@@ -91,16 +85,12 @@ export async function writeCodeUntilCompilePassed<
         ...payloads,
         ...files,
         ...nodeModules,
-        ...Object.entries(entireCodes)
-          .map(([filename, { content }]) => {
-            return {
-              [filename]: content,
-            };
-          })
-          .reduce<Record<string, string>>(
-            (acc, cur) => Object.assign(acc, cur),
-            {},
-          ),
+        ...arrayToRecord(
+          Object.entries(entireCodes).map(([filename, { content }]) => [
+            filename,
+            content,
+          ]),
+        ),
       },
     });
 
@@ -121,35 +111,33 @@ export async function writeCodeUntilCompilePassed<
     }
   }
 
-  return Object.entries(entireCodes)
-    .filter(([filename]) => filename.startsWith("src/providers")) // filter only provider files
-    .map(([filename, value]) => {
-      return {
-        filename,
-        content: value.content,
-        endpoint: value.endpoint!,
-        location: value.location!,
-        name: value.name!,
-        role: value.role!,
-      };
-    });
+  return (
+    Object.entries(entireCodes)
+      // .filter(([filename]) => filename.startsWith("src/providers")) // filter only provider files
+      .map(([filename, value]) => {
+        return {
+          filename,
+          content: value.content,
+          endpoint: value.endpoint!,
+          location: value.location!,
+          name: value.name!,
+          role: value.role!,
+        };
+      })
+  );
 }
 
-async function loadTemplateFiles(
-  templateFiles: string[],
+async function loadTemplateFiles<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
 ): Promise<IAutoBeRealizeCompile.FileContentMap> {
-  const templateBasePath = path.join(
-    __dirname,
-    "../../../../../internals/template/realize",
-  );
+  const templateFiles = await (await ctx.compiler()).realize.getTemplate();
+  const targets = ["src/MyGlobal.ts", "src/util/toISOStringSafe.ts"];
 
   const result: IAutoBeRealizeCompile.FileContentMap = {};
 
-  for (const filePath of templateFiles) {
+  for (const filePath of targets) {
     result[filePath] = {
-      content: await readFile(path.join(templateBasePath, filePath), {
-        encoding: "utf-8",
-      }),
+      content: templateFiles[filePath],
       result: "success",
       location: filePath,
       role: null,
@@ -171,7 +159,7 @@ async function process<Model extends ILlmSchema.Model>(
     op,
     (op) => orchestrateRealizePlanner(ctx, op, decorator),
     async (p) => {
-      const filename = `src/providers/${p.functionName}.ts` as const;
+      const filename = RealizeFileSystem.providerPath(p.functionName);
       const t = diagnostics.total.filter((el) => el.file === filename);
 
       const d = diagnostics.current.filter((el) => el.file === filename);
@@ -204,6 +192,16 @@ async function process<Model extends ILlmSchema.Model>(
   return { type: "success", op: op, result } as const;
 }
 
+/**
+ * Determines whether an operation should be processed in the current iteration.
+ * In the initial case (no errors), all operations are processed. When errors
+ * exist, only operations with compilation errors are targeted for reprocessing
+ * in the next iteration.
+ *
+ * @param op - The operation to check
+ * @param currentDiagnostics - Current compilation errors
+ * @returns True if the operation should be processed
+ */
 function shouldProcessOperation(
   op: AutoBeOpenApi.IOperation,
   currentDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
@@ -219,6 +217,14 @@ function shouldProcessOperation(
   );
 }
 
+/**
+ * Generates a provider filename for an operation. Converts the operation's HTTP
+ * method and path into a valid TypeScript filename. The filename serves as both
+ * the function name and the file identifier.
+ *
+ * @param op - The operation to generate a filename for
+ * @returns The generated provider filename with path
+ */
 function generateProviderFilename(op: AutoBeOpenApi.IOperation): string {
   return `src/providers/${op.method}_${op.path
     .replaceAll("/", "_")

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

@@ -52,6 +52,7 @@ function filterDocument(
       ),
   );
   const components: AutoBeOpenApi.IComponents = {
+    authorization: document.components.authorization,
     schemas: {},
   };
   const visit = (typeName: string) => {

package/src/orchestrate/test/orchestrateTestCorrect.ts

@@ -136,6 +136,9 @@ const correct = async <Model extends ILlmSchema.Model>(
     });
   if (pointer.value === null) throw new Error("Failed to modify test code.");
 
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+  pointer.value.final = await compiler.typescript.beautify(pointer.value.final);
+
   ctx.dispatch({
     type: "testCorrect",
     created_at: new Date().toISOString(),

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -150,9 +150,11 @@ const execute = async <Model extends ILlmSchema.Model>(
     ctx.usage().record(tokenUsage, ["test"]);
   });
   if (pointer.value.length === 0) {
-    throw new Error("Failed to create test plans.");
+    console.error("Failed to create test plans. No function called.");
+    return [];
+    // @todo
+    // throw new Error("Failed to create test plans.");
   }
-
   return pointer.value;
 };
 

package/src/orchestrate/test/orchestrateTestWrite.ts

@@ -1,5 +1,9 @@
 import { IAgenticaController, MicroAgentica } from "@agentica/core";
-import { AutoBeTestScenario, AutoBeTestWriteEvent } from "@autobe/interface";
+import {
+  AutoBeTestScenario,
+  AutoBeTestWriteEvent,
+  IAutoBeCompiler,
+} from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
@@ -106,6 +110,9 @@ async function process<Model extends ILlmSchema.Model>(
     ctx.usage().record(tokenUsage, ["test"]);
   });
   if (pointer.value === null) throw new Error("Failed to create test code.");
+
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+  pointer.value.final = await compiler.typescript.beautify(pointer.value.final);
   return pointer.value;
 }
 

package/src/utils/arrayToRecord.ts

@@ -0,0 +1,49 @@
+/**
+ * Converts an array of key-value pairs (entries) into a Record.
+ *
+ * @param entries - Array of [key, value] tuples
+ * @returns Record object from the entries
+ */
+export function arrayToRecord<V>(
+  entries: Array<[string, V]>,
+): Record<string, V>;
+
+/**
+ * Converts an array of objects into a Record using specified key and value
+ * properties.
+ *
+ * @param items - Array of items to convert
+ * @param keyProp - Property name to use as the key
+ * @param valueProp - Property name to use as the value
+ * @returns Record object with the extracted key-value pairs
+ */
+export function arrayToRecord<T, K extends keyof T, V extends keyof T>(
+  items: T[],
+  keyProp: K,
+  valueProp: V,
+): Record<string, T[V]>;
+
+export function arrayToRecord<T, K extends keyof T, V extends keyof T>(
+  items: T[] | Array<[string, any]>,
+  keyProp?: K,
+  valueProp?: V,
+): Record<string, any> {
+  // Handle entries format [string, value][]
+  if (items.length > 0 && Array.isArray(items[0]) && items[0].length === 2) {
+    return (items as Array<[string, any]>).reduce(
+      (acc, [key, value]) => Object.assign(acc, { [key]: value }),
+      {},
+    );
+  }
+
+  // Handle object array format with key and value properties
+  if (keyProp !== undefined && valueProp !== undefined) {
+    return (items as T[])
+      .map((item) => ({
+        [String(item[keyProp])]: item[valueProp],
+      }))
+      .reduce((acc, cur) => Object.assign(acc, cur), {});
+  }
+
+  throw new Error("Invalid arguments for arrayToRecord");
+}

package/src/utils/backoffRetry.ts

@@ -57,7 +57,6 @@ export function randomBackoffStrategy(props: {
   count: number;
   error: unknown;
 }): number {
-  console.log("randomBackoffStrategy");
   const { count, error } = props;
   if (count > 5) {
     throw error;

package/lib/orchestrate/interface/OpenApiEndpointComparator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"OpenApiEndpointComparator.js","sourceRoot":"","sources":["../../../src/orchestrate/interface/OpenApiEndpointComparator.ts"],"names":[],"mappings":";;;AACA,+BAA4B;AAE5B,IAAiB,yBAAyB,CAWzC;AAXD,WAAiB,yBAAyB;IACxC,SAAgB,QAAQ,CAAC,CAA0B;QACjD,OAAO,IAAA,WAAI,EAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAFe,kCAAQ,WAEvB,CAAA;IAED,SAAgB,MAAM,CACpB,CAA0B,EAC1B,CAA0B;QAE1B,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,CAAC;IACpD,CAAC;IALe,gCAAM,SAKrB,CAAA;AACH,CAAC,EAXgB,yBAAyB,yCAAzB,yBAAyB,QAWzC"}

package/lib/orchestrate/interface/orchestrateInterfaceComponents.d.ts

@@ -1,4 +0,0 @@
-import { AutoBeOpenApi } from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestrateInterfaceComponents<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operations: AutoBeOpenApi.IOperation[], capacity?: number): Promise<AutoBeOpenApi.IComponents>;