@autobe/agent 0.22.0 → 0.23.0

package/src/orchestrate/interface/utils/JsonSchemaValidator.ts

@@ -0,0 +1,71 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeOpenApiTypeChecker, StringUtil } from "@autobe/utils";
+import { IValidation } from "typia";
+import { Escaper } from "typia/lib/utils/Escaper";
+
+export namespace JsonSchemaValidator {
+  export interface IProps {
+    errors: IValidation.IError[];
+    schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    path: string;
+  }
+
+  export const validateSchemas = (props: IProps): void => {
+    authorization(props);
+    for (const key of Object.keys(props.schemas))
+      validateKey({
+        errors: props.errors,
+        path: props.path,
+        key,
+      });
+  };
+
+  export const validateKey = (props: {
+    errors: IValidation.IError[];
+    path: string;
+    key: string;
+  }): void => {
+    const variable: boolean = props.key.split(".").every(Escaper.variable);
+    if (variable === false)
+      props.errors.push({
+        path: `${props.path}[${JSON.stringify(props.key)}]`,
+        expected: "Valid variable name",
+        value: props.key,
+        description: StringUtil.trim`
+            JSON schema type name must be a valid variable name.
+
+            Even though JSON schema type name allows dot(.) character, but
+            each segment separated by dot(.) must be a valid variable name.
+
+            Current key name ${JSON.stringify(props.key)} is not valid. Change
+            it to a valid variable name at the next time.
+          `,
+      });
+  };
+
+  const authorization = (props: IProps): void => {
+    for (const [key, value] of Object.entries(props.schemas)) {
+      if (!key.endsWith(".IAuthorized")) continue;
+      else if (AutoBeOpenApiTypeChecker.isObject(value) === false) {
+        props.errors.push({
+          path: `${props.path}.${key}`,
+          expected: `AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema.IObject>`,
+          value: value,
+          description: `${key} must be an object type for authorization responses`,
+        });
+        continue;
+      }
+
+      // Check if token property exists
+      value.properties ??= {};
+      value.properties["token"] = {
+        $ref: "#/components/schemas/IAuthorizationToken",
+        description: "JWT token information for authentication",
+      } as AutoBeOpenApi.IJsonSchemaDescriptive.IReference;
+
+      value.required ??= [];
+      if (value.required.includes("token") === false)
+        value.required.push("token");
+    }
+  };
+}

package/src/orchestrate/interface/utils/OperationValidator.ts

@@ -0,0 +1,127 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeEndpointComparator, StringUtil } from "@autobe/utils";
+import { HashMap } from "tstl";
+import { IValidation } from "typia";
+import { Escaper } from "typia/lib/utils/Escaper";
+
+import { emplaceMap } from "../../../utils/emplaceMap";
+import { JsonSchemaValidator } from "./JsonSchemaValidator";
+
+export namespace OperationValidator {
+  export interface IProps {
+    errors: IValidation.IError[];
+    path: string;
+    operations: Array<
+      Omit<AutoBeOpenApi.IOperation, "authorizationRole" | "authorizationType">
+    >;
+  }
+  export const validate = (props: IProps): void => {
+    props.operations.forEach((op, i) => {
+      // get method has request body
+      if (op.method === "get" && op.requestBody !== null)
+        props.errors.push({
+          path: `${props.path}[${i}].requestBody`,
+          expected:
+            "GET method should not have request body. Change method, or re-design the operation.",
+          value: op.requestBody,
+        });
+      // operation name
+      if (Escaper.variable(op.name) === false)
+        props.errors.push({
+          path: `${props.path}[${i}].name`,
+          expected: "<valid_variable_name>",
+          value: op.name,
+          description: StringUtil.trim`
+            The operation name will be converted to the API controller method
+            (function) name, so the operation.name must be a valid JavaScript 
+            variable/function name.
+
+            However, what you've configured value ${JSON.stringify(op.name)}
+            is not a valid JavaScript variable/function name. Please change
+            it to a valid variable/function name.
+          `,
+        });
+      // validate types
+      if (op.requestBody !== null)
+        JsonSchemaValidator.validateKey({
+          errors: props.errors,
+          path: `${props.path}[${i}].requestBody.typeName`,
+          key: op.requestBody.typeName,
+        });
+      if (op.responseBody !== null)
+        JsonSchemaValidator.validateKey({
+          errors: props.errors,
+          path: `${props.path}[${i}].responseBody.typeName`,
+          key: op.responseBody.typeName,
+        });
+    });
+
+    // validate duplicated endpoints
+    const endpoints: HashMap<AutoBeOpenApi.IEndpoint, number[]> = new HashMap(
+      AutoBeEndpointComparator.hashCode,
+      AutoBeEndpointComparator.equals,
+    );
+    props.operations.forEach((op, i) => {
+      const key: AutoBeOpenApi.IEndpoint = {
+        path: op.path,
+        method: op.method,
+      };
+      const it = endpoints.find(key);
+      if (it.equals(endpoints.end()) === false) {
+        const indexes: number[] = it.second;
+        props.errors.push({
+          path: `${props.path}[${i}].{"path"|"method"}`,
+          expected: "Unique endpoint (path and method)",
+          value: key,
+          description: StringUtil.trim`
+            Duplicated endpoint detected (method: ${op.method}, path: ${op.path}).
+
+            The duplicated endpoints of others are located in below accessors.
+            Check them, and consider which operation endpoint would be proper to modify.
+            
+            ${indexes
+              .map((idx) => `- ${props.path}.[${idx}].{"path"|"method"}`)
+              .join("\n")}
+          `,
+        });
+        indexes.push(i);
+      } else endpoints.emplace(key, [i]);
+    });
+
+    // validate duplicated method names
+    const accessors: Map<string, number[]> = new Map();
+    props.operations.forEach((op, i) => {
+      const key: string =
+        op.path
+          .split("/")
+          .filter((e) => e[0] !== "{" && e.at(-1) !== "}")
+          .filter((e) => e.length !== 0)
+          .join(".") + `.${op.name}`;
+      const indexes: number[] = emplaceMap(accessors, key, () => []);
+      if (indexes.length !== 0) {
+        props.errors.push({
+          path: `${props.path}[${i}].name`,
+          expected: "Unique name in the same accessor scope.",
+          value: op.name,
+          description: StringUtil.trim`
+            Duplicated operation accessor detected (name: ${op.name}, accessor: ${key}).
+
+            The operation name must be unique within the parent accessor.
+            In other worlds, the operation accessor determined by the name
+            must be unique in the OpenAPI document.
+
+            Here is the list of elements of duplicated operation names.
+            Check them, and consider which operation name would be proper to modify.
+
+            ${indexes
+              .map(
+                (idx) => `- ${props.operations[idx].name} (accessor: ${key})`,
+              )
+              .join("\n")}
+          `,
+        });
+      }
+      indexes.push(i);
+    });
+  };
+}

package/src/orchestrate/prisma/orchestratePrismaCorrect.ts

@@ -27,7 +27,7 @@ export function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(
       return true;
     });
   application.files = application.files.filter((f) => f.models.length !== 0);
-  return iterate(ctx, application, ctx.retry);
+  return iterate(ctx, application, Math.max(ctx.retry, 5));
 }
 
 async function iterate<Model extends ILlmSchema.Model>(
@@ -40,7 +40,7 @@ async function iterate<Model extends ILlmSchema.Model>(
     await compiler.prisma.validate(application);
   if (result.success)
     return result; // SUCCESS
-  else if (life <= 0) return result; // FAILURE
+  else if (life < 0) return result; // FAILURE
 
   // VALIDATION FAILED
   const schemas: Record<string, string> = await compiler.prisma.write(

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

@@ -22,6 +22,12 @@ export function transformRealizeCorrectHistories(props: {
 > {
   return [
     ...transformRealizeWriteHistories(props),
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.COMMON_CORRECT_CASTING,
+    },
     {
       id: v7(),
       type: "assistantMessage",

package/src/orchestrate/realize/orchestRateRealizeCorrectCasting.ts

@@ -0,0 +1,317 @@
+import {
+  AutoBeProgressEventBase,
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeFunction,
+  AutoBeRealizeValidateEvent,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { ILlmApplication, ILlmController, ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+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 { compileRealizeFiles } from "./internal/compileRealizeFiles";
+
+/** Result of attempting to correct a single function */
+type CorrectionResult = {
+  result: "success" | "ignore" | "exception";
+  func: AutoBeRealizeFunction;
+};
+
+export const orchestrateRealizeCorrectCasting = async <
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  authorizations: AutoBeRealizeAuthorization[],
+  functions: AutoBeRealizeFunction[],
+  progress: AutoBeProgressEventBase,
+  life: number = ctx.retry,
+): Promise<AutoBeRealizeFunction[]> => {
+  const validateEvent: AutoBeRealizeValidateEvent = await compileRealizeFiles(
+    ctx,
+    {
+      authorizations,
+      functions,
+    },
+  );
+
+  return predicate(
+    ctx,
+    authorizations,
+    functions,
+    [],
+    progress,
+    validateEvent,
+    life,
+  );
+};
+
+const predicate = async <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  authorizations: AutoBeRealizeAuthorization[],
+  functions: AutoBeRealizeFunction[],
+  failures: IAutoBeTypeScriptCompileResult.IDiagnostic[],
+  progress: AutoBeProgressEventBase,
+  event: AutoBeRealizeValidateEvent,
+  life: number,
+): Promise<AutoBeRealizeFunction[]> => {
+  if (event.result.type === "failure") {
+    ctx.dispatch(event);
+
+    return await correct(
+      ctx,
+      authorizations,
+      functions,
+      [...failures, ...event.result.diagnostics],
+      progress,
+      event,
+      life,
+    );
+  }
+  return functions;
+};
+
+const correct = async <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  authorizations: AutoBeRealizeAuthorization[],
+  functions: AutoBeRealizeFunction[],
+  failures: IAutoBeTypeScriptCompileResult.IDiagnostic[],
+  progress: AutoBeProgressEventBase,
+  event: AutoBeRealizeValidateEvent,
+  life: number,
+): Promise<AutoBeRealizeFunction[]> => {
+  // Early returns for non-correctable cases
+  if (event.result.type !== "failure" || life < 0) {
+    return functions;
+  }
+
+  const locations: string[] = diagnose(event).filter((l) =>
+    functions.map((f) => f.location).includes(l),
+  );
+  progress.total += locations.length;
+
+  const converted: CorrectionResult[] = await executeCachedBatch(
+    locations.map((location) => async (): Promise<CorrectionResult> => {
+      const func: AutoBeRealizeFunction = functions.find(
+        (f) => f.location === location,
+      )!;
+
+      const pointer: IPointer<
+        IAutoBeCommonCorrectCastingApplication.IProps | false | null
+      > = {
+        value: null,
+      };
+
+      const { tokenUsage } = await ctx.conversate({
+        source: "realizeCorrect",
+        histories: transformCommonCorrectCastingHistories([
+          {
+            script: func.content,
+            diagnostics: failures.filter((d) => d.file === location),
+          },
+        ]),
+        controller: createController({
+          model: ctx.model,
+          then: (next) => {
+            pointer.value = next;
+          },
+          reject: () => {
+            pointer.value = false;
+          },
+        }),
+        enforceFunctionCall: true,
+        message: StringUtil.trim`
+          Fix the TypeScript casting problems to resolve the compilation error.
+
+          Most casting errors are caused by type mismatches between Date types and 
+          string & tags.Format<'date-time'>. To fix these:
+          - Use the pre-provided toISOStringSafe() function to convert Date to string
+          - Or use Date object's .toISOString() method
+          - Never use Date type directly in declarations or return values
+
+          You don't need to explain me anything, but just fix or give it up 
+          immediately without any hesitation, explanation, and questions.
+        `,
+      });
+      ++progress.completed;
+      if (pointer.value === null)
+        return { result: "exception" as const, func: func };
+      else if (pointer.value === false)
+        return { result: "ignore" as const, func: func };
+
+      ctx.dispatch({
+        id: v7(),
+        type: "realizeCorrect",
+        content: pointer.value.revise.final,
+        created_at: new Date().toISOString(),
+        location: func.location,
+        step: ctx.state().analyze?.step ?? 0,
+        tokenUsage,
+        completed: progress.completed,
+        total: progress.total,
+      });
+
+      return {
+        result: "success" as const,
+        func: { ...func, content: pointer.value.revise.final },
+      };
+    }),
+  );
+
+  const newValidate: AutoBeRealizeValidateEvent = await compileRealizeFiles(
+    ctx,
+    { authorizations, functions: converted.map((c) => c.func) },
+  );
+
+  if (newValidate.result.type === "success") {
+    return converted.map((c) => c.func);
+  }
+
+  const newLocations: string[] = diagnose(newValidate);
+
+  // Separate successful, failed, and ignored corrections
+  const { success, failed, ignored } = separateCorrectionResults(
+    converted,
+    newLocations,
+  );
+
+  // If no failures to retry, return success and ignored functions
+  if (failed.length === 0) {
+    return [...success, ...ignored];
+  }
+
+  // Collect diagnostics relevant to failed functions
+  const failedLocations: string[] = failed.map((f) => f.location);
+  const allDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[] = [
+    ...failures,
+    ...(newValidate.result.type === "failure"
+      ? newValidate.result.diagnostics
+      : []),
+  ];
+  const relevantDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[] =
+    filterRelevantDiagnostics(allDiagnostics, failedLocations);
+
+  // Recursively retry failed functions
+  const retriedFunctions: AutoBeRealizeFunction[] = await predicate(
+    ctx,
+    authorizations,
+    failed,
+    relevantDiagnostics,
+    progress,
+    newValidate,
+    life - 1,
+  );
+
+  return [...success, ...ignored, ...retriedFunctions];
+};
+
+/**
+ * Extract unique file locations from validation event diagnostics
+ *
+ * @param event - Validation event containing compilation results
+ * @returns Array of unique file paths that have errors
+ */
+const diagnose = (event: AutoBeRealizeValidateEvent): string[] => {
+  if (event.result.type !== "failure") {
+    return [];
+  }
+
+  const diagnostics = event.result.diagnostics;
+  const locations = diagnostics
+    .map((d) => d.file)
+    .filter((f): f is string => f !== null);
+
+  return Array.from(new Set(locations));
+};
+
+/**
+ * Separate correction results into successful, failed, and ignored functions
+ *
+ * @param corrections - Array of correction results
+ * @param errorLocations - File paths that still have errors
+ * @returns Object with success, failed, and ignored function arrays
+ */
+const separateCorrectionResults = (
+  corrections: CorrectionResult[],
+  errorLocations: string[],
+): {
+  success: AutoBeRealizeFunction[];
+  failed: AutoBeRealizeFunction[];
+  ignored: AutoBeRealizeFunction[];
+} => {
+  const success = corrections
+    .filter(
+      (c) =>
+        c.result === "success" && !errorLocations.includes(c.func.location),
+    )
+    .map((c) => c.func);
+
+  const failed = corrections
+    .filter(
+      (c) => c.result === "success" && errorLocations.includes(c.func.location),
+    )
+    .map((c) => c.func);
+
+  const ignored = corrections
+    .filter((c) => c.result === "ignore" || c.result === "exception")
+    .map((c) => c.func);
+
+  return { success, failed, ignored };
+};
+
+/**
+ * Filter diagnostics to only include those relevant to specific functions
+ *
+ * @param diagnostics - All diagnostics
+ * @param functionLocations - Locations of functions to filter for
+ * @returns Filtered diagnostics
+ */
+const filterRelevantDiagnostics = (
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
+  functionLocations: string[],
+): IAutoBeTypeScriptCompileResult.IDiagnostic[] => {
+  return diagnostics.filter(
+    (d) => d.file && functionLocations.includes(d.file),
+  );
+};
+
+const createController = <Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  then: (next: IAutoBeCommonCorrectCastingApplication.IProps) => void;
+  reject: () => void;
+}): ILlmController<Model> => {
+  assertSchemaModel(props.model);
+  const application = collection[
+    props.model === "chatgpt" ? "chatgpt" : "claude"
+  ] satisfies ILlmApplication<any> as any as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "correctInvalidRequest",
+    application,
+    execute: {
+      rewrite: (next) => {
+        props.then(next);
+      },
+      reject: () => {
+        props.reject();
+      },
+    } satisfies IAutoBeCommonCorrectCastingApplication,
+  };
+};
+
+const collection = {
+  chatgpt: typia.llm.application<
+    IAutoBeCommonCorrectCastingApplication,
+    "chatgpt"
+  >(),
+  claude: typia.llm.application<
+    IAutoBeCommonCorrectCastingApplication,
+    "claude"
+  >(),
+};

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -15,11 +15,14 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { predicateStateMessage } from "../../utils/predicateStateMessage";
+import { compileRealizeFiles } from "./internal/compileRealizeFiles";
+import { orchestrateRealizeCorrectCasting } from "./orchestRateRealizeCorrectCasting";
 import { orchestrateRealizeAuthorization } from "./orchestrateRealizeAuthorization";
 import { orchestrateRealizeCorrect } from "./orchestrateRealizeCorrect";
-import { orchestrateRealizeScenario } from "./orchestrateRealizeScenario";
 import { orchestrateRealizeWrite } from "./orchestrateRealizeWrite";
+import { IAutoBeRealizeFunctionFailure } from "./structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
+import { generateRealizeScenario } from "./utils/generateRealizeScenario";
 
 export const orchestrateRealize =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
@@ -59,13 +62,7 @@ export const orchestrateRealize =
 
     // SCENARIOS
     const scenarios: IAutoBeRealizeScenarioResult[] = operations.map(
-      (operation) => {
-        const authorization = authorizations.find(
-          (el) => el.role.name === operation.authorizationRole,
-        );
-
-        return orchestrateRealizeScenario(ctx, operation, authorization);
-      },
+      (operation) => generateRealizeScenario(ctx, operation, authorizations),
     );
 
     const writeProgress: AutoBeProgressEventBase = {
@@ -107,24 +104,42 @@ export const orchestrateRealize =
       completed: writeEvents.length,
     };
 
-    const result = await orchestrateRealizeCorrect(
+    const converted: AutoBeRealizeFunction[] =
+      await orchestrateRealizeCorrectCasting(
+        ctx,
+        authorizations,
+        functions,
+        reviewProgress,
+      );
+
+    console.log("converted end");
+    console.log("converted end");
+    console.log("converted end");
+    console.log("converted end");
+    console.log("converted end");
+    console.log("converted end");
+    const corrected: AutoBeRealizeFunction[] = await orchestrateRealizeCorrect(
       ctx,
       scenarios,
       authorizations,
-      functions,
-      [],
+      converted,
+      [] satisfies IAutoBeRealizeFunctionFailure[],
       reviewProgress,
-      5,
     );
 
     const compiler: IAutoBeCompiler = await ctx.compiler();
     const controllers: Record<string, string> =
       await compiler.realize.controller({
         document: ctx.state().interface!.document,
-        functions,
+        functions: corrected,
         authorizations,
       });
 
+    const { result } = await compileRealizeFiles(ctx, {
+      authorizations,
+      functions: corrected,
+    });
+
     return ctx.dispatch({
       type: "realizeComplete",
       id: v7(),
@@ -132,7 +147,7 @@ export const orchestrateRealize =
       functions,
       authorizations,
       controllers,
-      compiled: result.result,
+      compiled: result,
       step: ctx.state().analyze?.step ?? 0,
       elapsed: new Date().getTime() - start.getTime(),
     });

package/src/orchestrate/realize/orchestrateRealizeAuthorizationCorrect.ts

@@ -68,7 +68,7 @@ export async function orchestrateRealizeAuthorizationCorrect<
 
   if (compiled.type === "success") {
     return authorization;
-  } else if (compiled.type === "exception" || life === 0) {
+  } else if (compiled.type === "exception" || life < 0) {
     return authorization;
   }