@autobe/agent 0.25.0 → 0.25.1

package/src/factory/createAutoBeContext.ts

@@ -318,6 +318,7 @@ const createDispatch = (props: {
           instruction: interfaceStart?.reason ?? "",
           authorizations: event.authorizations,
           document: event.document,
+          missed: event.missed,
           created_at: interfaceStart?.created_at ?? new Date().toISOString(),
           completed_at: new Date().toISOString(),
           step: event.step,

package/src/orchestrate/common/orchestrateCommonCorrectCasting.ts

@@ -120,7 +120,7 @@ const correct = async <
       think: pointer.value.think,
       draft: pointer.value.draft,
       review: pointer.value.revise.review,
-      final: pointer.value.revise.final,
+      final: pointer.value.revise.final ?? undefined,
       tokenUsage,
     }),
   );
@@ -129,7 +129,7 @@ const correct = async <
     factory,
     [...failures, event],
     script,
-    await factory.validate(pointer.value.revise.final),
+    await factory.validate(pointer.value.revise.final ?? pointer.value.draft),
     life - 1,
   );
 };

package/src/orchestrate/common/structures/IAutoBeCommonCorrectCastingApplication.ts

@@ -1,44 +1,22 @@
-/**
- * Function calling interface for fixing TypeScript type casting and assignment errors.
- *
- * This interface is used by the CommonCorrectCasting agent to fix TypeScript
- * compilation errors related to type casting and type assignment incompatibilities
- * in any TypeScript code, not limited to e2e tests.
- *
- * The agent handles various type casting issues including:
- *
- * - **Typia tag type incompatibilities**: Format tag mismatches (e.g., Format<"uuid"> 
- *   vs Pattern<...>), type constraint incompatibilities (e.g., Type<"int32"> vs 
- *   Type<"int32"> & Minimum<0>), nullable type conversions with tags
- * - **Date to string conversions**: Date to string, Date to string & Format<"date-time">, 
- *   nullable Date handling
- * - **Nullable and undefined type assignments**: Exhaustive type narrowing for 
- *   T | null | undefined patterns
- * - **String to literal type assignments**: Converting general string to literal 
- *   union types (e.g., "pending" | "approved" | "rejected")
- * - **Optional chaining with union types**: Handling boolean | undefined results 
- *   from array methods like includes()
- * - **Type narrowing "no overlap" errors**: Removing redundant comparisons after 
- *   TypeScript's control flow analysis
- *
- * @author Samchon
- */
 export interface IAutoBeCommonCorrectCastingApplication {
   /**
    * Rewrite function to fix type casting and assignment errors.
    *
-   * This function is called when the agent detects any type casting or assignment
-   * related compilation error patterns.
+   * This function is called when the agent detects any type casting or
+   * assignment related compilation error patterns.
    *
    * The agent applies various fix strategies based on the error type:
    *
-   * - **Typia tag incompatibilities**: Uses `satisfies ... as ...` pattern to strip 
-   *   incompatible tags, or `typia.assert<T>()` as a last resort
-   * - **Date conversions**: Uses `.toISOString()` method for Date to string conversions
-   * - **Nullable type narrowing**: Applies exhaustive checks (e.g., !== null && !== undefined)
-   * - **typia.assert vs assertGuard**: Uses assert for value assignment, assertGuard 
-   *   for type narrowing
-   * - **Literal type conversions**: Uses `typia.assert<T>()` for runtime validation
+   * - **Typia tag incompatibilities**: Uses `satisfies ... as ...` pattern to
+   *   strip incompatible tags, or `typia.assert<T>()` as a last resort
+   * - **Date conversions**: Uses `.toISOString()` method for Date to string
+   *   conversions
+   * - **Nullable type narrowing**: Applies exhaustive checks (e.g., !== null &&
+   *   !== undefined)
+   * - **typia.assert vs assertGuard**: Uses assert for value assignment,
+   *   assertGuard for type narrowing
+   * - **Literal type conversions**: Uses `typia.assert<T>()` for runtime
+   *   validation
    * - **Optional chaining results**: Uses `=== true` or `??` operators
    * - **"No overlap" errors**: Removes redundant comparisons
    *
@@ -52,24 +30,20 @@ export interface IAutoBeCommonCorrectCastingApplication {
   /**
    * Reject function when error is not related to type casting or assignment.
    *
-   * This function is called when the compilation error is unrelated to type 
-   * casting issues (e.g., missing imports, syntax errors, undefined variables), 
+   * This function is called when the compilation error is unrelated to type
+   * casting issues (e.g., missing imports, syntax errors, undefined variables),
    * indicating the error should be handled by a different agent.
    */
   reject(): void;
 }
 export namespace IAutoBeCommonCorrectCastingApplication {
-  /**
-   * Properties for the rewrite function containing the type casting error
-   * analysis and correction workflow.
-   */
   export interface IProps {
     /**
      * Initial analysis of the type casting or assignment error.
      *
      * Contains the agent's analysis of the specific type mismatch pattern:
      *
-     * - Type of casting error (tag incompatibility, nullable assignment, literal 
+     * - Type of casting error (tag incompatibility, nullable assignment, literal
      *   type conversion, etc.)
      * - Whether nullable or undefined types are involved
      * - If Date to string conversions are needed
@@ -94,12 +68,12 @@ export namespace IAutoBeCommonCorrectCastingApplication {
      * Review and finalization of type casting corrections.
      *
      * Contains the review of applied corrections and the final code with all
-     * type casting issues resolved while preserving type safety and validation intent.
+     * type casting issues resolved while preserving type safety and validation
+     * intent.
      */
     revise: IReviseProps;
   }
 
-  /** Properties for the revision phase of type casting corrections. */
   export interface IReviseProps {
     /**
      * Review of the type casting correction patterns applied.
@@ -120,8 +94,14 @@ export namespace IAutoBeCommonCorrectCastingApplication {
      *
      * The complete code ready for TypeScript compilation, with all type casting
      * and assignment errors properly fixed using appropriate patterns while
-     * maintaining type safety and the original validation logic.
+     * maintaining type safety and the original validation logic. When the draft
+     * already successfully resolves all type casting issues with no problems
+     * found during review, this value can be null, indicating no further
+     * refinements are necessary.
+     *
+     * A `null` value signifies the draft corrections were already optimal and
+     * require no additional modifications.
      */
-    final: string;
+    final: string | null;
   }
 }

package/src/orchestrate/interface/histories/{transformInterfacePrerequisiteHistories.ts → transformInterfaceCommonPrerequisiteHistories.ts}

@@ -3,7 +3,7 @@ import { v7 } from "uuid";
 
 import { AutoBeState } from "../../../context/AutoBeState";
 
-export const transformInterfacePrerequisiteHistories = (
+export const transformInterfaceCommonPrerequisiteHistories = (
   state: AutoBeState,
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage

package/src/orchestrate/interface/histories/transformInterfaceGroupHistories.ts

@@ -5,7 +5,7 @@ import { v7 } from "uuid";
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
 import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHistories";
-import { transformInterfacePrerequisiteHistories } from "./transformInterfacePrerequisiteHistories";
+import { transformInterfaceCommonPrerequisiteHistories } from "./transformInterfaceCommonPrerequisiteHistories";
 
 export const transformInterfaceGroupHistories = (props: {
   state: AutoBeState;
@@ -13,7 +13,9 @@ export const transformInterfaceGroupHistories = (props: {
 }): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
-  const prerequisite = transformInterfacePrerequisiteHistories(props.state);
+  const prerequisite = transformInterfaceCommonPrerequisiteHistories(
+    props.state,
+  );
   if (prerequisite !== null) return prerequisite;
 
   return [

package/src/orchestrate/interface/histories/transformInterfacePrerequisitesHistories.ts

@@ -0,0 +1,118 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { OpenApiTypeChecker } from "@samchon/openapi";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { getReferenceIds } from "../../test/utils/getReferenceIds";
+
+export const transformInterfacePrerequisitesHistories = (
+  document: AutoBeOpenApi.IDocument,
+  include: AutoBeOpenApi.IOperation[],
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  const domainSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
+    {};
+  const visit = (key: string) =>
+    OpenApiTypeChecker.visit({
+      schema: {
+        $ref: `#/components/schemas/${key}`,
+      },
+      components: document.components,
+      closure: (next) => {
+        if (OpenApiTypeChecker.isReference(next))
+          domainSchemas[next.$ref.split("/").pop()!] =
+            document.components.schemas[next.$ref.split("/").pop()!];
+      },
+    });
+  for (const op of include) {
+    if (op.requestBody) visit(op.requestBody.typeName);
+    if (op.responseBody) visit(op.responseBody.typeName);
+  }
+
+  return [
+    {
+      type: "systemMessage",
+      id: v7(),
+      created_at: new Date().toISOString(),
+      text: AutoBeSystemPromptConstant.INTERFACE_PREREQUISITE,
+    },
+    {
+      type: "assistantMessage",
+      id: v7(),
+      created_at: new Date().toISOString(),
+      text: StringUtil.trim`
+        ## Document Overview
+
+        ### Entire API Operations
+        
+        All operations in this project for prerequisite references.
+
+        These are the complete list of API endpoints that can be used 
+        as prerequisites. You should select appropriate operations from 
+        this list when establishing dependency chains.
+
+        \`\`\`json
+        ${JSON.stringify({
+          operations: document.operations
+            .filter(
+              (op) => op.authorizationType === null && op.method === "post",
+            )
+            .map((op) => {
+              return {
+                ...op,
+                prerequisites: undefined,
+              };
+            }),
+        })}
+        \`\`\`
+
+        ### Entire Schema Definitions
+
+        Data structure definitions to understand entity relationships.
+
+        Use these schemas to identify parent-child relationships and 
+        data dependencies between operations.
+
+        \`\`\`json
+        ${JSON.stringify({
+          components: {
+            schemas: document.components.schemas,
+          },
+        })}
+        \`\`\`
+            
+        ## Target Operations and Schemas
+
+        ### Target Operations
+
+        Operations requiring prerequisite analysis.
+        
+        For each of these operations, analyze if they need any prerequisites 
+        from the available operations above. Add prerequisites only when there 
+        are genuine dependencies like resource existence checks or state validations.
+
+        \`\`\`json
+        ${JSON.stringify(
+          include.map((op) => {
+            return {
+              ...op,
+              requiredIds: getReferenceIds({ document, operation: op }),
+            };
+          }),
+        )}
+        \`\`\`
+
+        ### Domain Schemas
+
+        Schema definitions for the target operations.
+
+        \`\`\`json
+        ${JSON.stringify(domainSchemas)}
+        \`\`\`
+      `,
+    },
+  ];
+};

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -6,7 +6,12 @@ import {
   AutoBeInterfaceHistory,
   AutoBeOpenApi,
 } from "@autobe/interface";
-import { AutoBeEndpointComparator } from "@autobe/utils";
+import { AutoBeInterfacePrerequisite } from "@autobe/interface/src/histories/contents/AutoBeInterfacePrerequisite";
+import {
+  AutoBeOpenApiEndpointComparator,
+  missedOpenApiSchemas,
+  revertOpenApiAccessor,
+} from "@autobe/utils";
 import { ILlmSchema } from "@samchon/openapi";
 import { HashMap, Pair } from "tstl";
 import { v7 } from "uuid";
@@ -19,8 +24,10 @@ import { orchestrateInterfaceComplement } from "./orchestrateInterfaceComplement
 import { orchestrateInterfaceEndpoints } from "./orchestrateInterfaceEndpoints";
 import { orchestrateInterfaceGroups } from "./orchestrateInterfaceGroups";
 import { orchestrateInterfaceOperations } from "./orchestrateInterfaceOperations";
+import { orchestrateInterfacePrerequisites } from "./orchestrateInterfacePrerequisites";
 import { orchestrateInterfaceSchemas } from "./orchestrateInterfaceSchemas";
 import { orchestrateInterfaceSchemasReview } from "./orchestrateInterfaceSchemasReview";
+import { JsonSchemaFactory } from "./utils/JsonSchemaFactory";
 
 export const orchestrateInterface =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
@@ -91,8 +98,8 @@ export const orchestrateInterface =
             o, // early inserted be kept
           ),
       ),
-      AutoBeEndpointComparator.hashCode,
-      AutoBeEndpointComparator.equals,
+      AutoBeOpenApiEndpointComparator.hashCode,
+      AutoBeOpenApiEndpointComparator.equals,
     )
       .toJSON()
       .map((it) => it.second);
@@ -109,31 +116,50 @@ export const orchestrateInterface =
       },
     };
 
-    const complementedSchemas: Record<
-      string,
-      AutoBeOpenApi.IJsonSchemaDescriptive
-    > = await orchestrateInterfaceComplement(ctx, {
-      instruction: props.instruction,
-      document,
-    });
-    Object.assign(document.components.schemas, complementedSchemas);
+    const complement = async () =>
+      Object.assign(
+        document.components.schemas,
+        await orchestrateInterfaceComplement(ctx, {
+          instruction: props.instruction,
+          document,
+        }),
+      );
+    await complement();
 
-    const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
+    Object.assign(
+      document.components.schemas,
       await orchestrateInterfaceSchemasReview(
         ctx,
         operations,
         document.components.schemas,
-      );
-    Object.assign(document.components.schemas, schemas);
-    for (const key of Object.keys(document.components.schemas))
-      if (key === "IPageI" || key.startsWith("IPageI."))
-        delete document.components.schemas[key];
+      ),
+    );
+    if (missedOpenApiSchemas(document).length !== 0) await complement();
+
+    JsonSchemaFactory.finalize({
+      document,
+      application: ctx.state().prisma!.result.data,
+    });
+
+    // CONNECT PRE-REQUISITES
+    const prerequisites: AutoBeInterfacePrerequisite[] =
+      await orchestrateInterfacePrerequisites(ctx, document);
+    document.operations.forEach((op) => {
+      op.prerequisites =
+        prerequisites.find(
+          (p) => p.endpoint.method === op.method && p.endpoint.path === op.path,
+        )?.prerequisites ?? [];
+    });
+
+    // NORMALIZE ACCESSORS
+    revertOpenApiAccessor(document);
 
     // DO COMPILE
     return ctx.dispatch({
       type: "interfaceComplete",
       id: v7(),
       document,
+      missed: missedOpenApiSchemas(document),
       authorizations,
       created_at: new Date().toISOString(),
       elapsed: new Date().getTime() - start.getTime(),

package/src/orchestrate/interface/orchestrateInterfaceComplement.ts

@@ -1,11 +1,7 @@
 import { IAgenticaController } from "@agentica/core";
 import { AutoBeOpenApi } from "@autobe/interface";
-import {
-  ILlmApplication,
-  ILlmSchema,
-  IValidation,
-  OpenApiTypeChecker,
-} from "@samchon/openapi";
+import { missedOpenApiSchemas } from "@autobe/utils";
+import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
 import { IPointer } from "tstl";
 import typia from "typia";
@@ -27,7 +23,7 @@ export function orchestrateInterfaceComplement<Model extends ILlmSchema.Model>(
     document: AutoBeOpenApi.IDocument;
   },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  return step(ctx, props, 8);
+  return step(ctx, props, false);
 }
 
 async function step<Model extends ILlmSchema.Model>(
@@ -36,10 +32,10 @@ async function step<Model extends ILlmSchema.Model>(
     instruction: string;
     document: AutoBeOpenApi.IDocument;
   },
-  life: number,
+  wasEmpty: boolean,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  const missed: string[] = getMissed(props.document);
-  if (missed.length === 0 || life < 0) return props.document.components.schemas;
+  const missed: string[] = missedOpenApiSchemas(props.document);
+  if (missed.length === 0) return props.document.components.schemas;
 
   const pointer: IPointer<Record<
     string,
@@ -88,6 +84,10 @@ async function step<Model extends ILlmSchema.Model>(
     created_at: new Date().toISOString(),
   });
 
+  const empty: boolean = Object.keys(pointer.value).length === 0;
+  if (empty === true && wasEmpty === true)
+    return props.document.components.schemas;
+
   const newSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {
     ...pointer.value,
     ...props.document.components.schemas,
@@ -105,31 +105,10 @@ async function step<Model extends ILlmSchema.Model>(
         },
       },
     },
-    life - 1,
+    empty,
   );
 }
 
-const getMissed = (document: AutoBeOpenApi.IDocument): string[] => {
-  const missed: Set<string> = new Set();
-  const check = (name: string) => {
-    if (document.components.schemas[name] === undefined) missed.add(name);
-  };
-  for (const op of document.operations) {
-    if (op.requestBody !== null) check(op.requestBody.typeName);
-    if (op.responseBody !== null) check(op.responseBody.typeName);
-  }
-  for (const value of Object.values(document.components.schemas))
-    OpenApiTypeChecker.visit({
-      components: document.components,
-      schema: value,
-      closure: (next) => {
-        if (OpenApiTypeChecker.isReference(next))
-          check(next.$ref.split("/").pop()!);
-      },
-    });
-  return Array.from(missed);
-};
-
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (
@@ -141,7 +120,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
   const validate = (
     next: unknown,
   ): IValidation<IAutoBeInterfaceComplementApplication.IProps> => {
-    JsonSchemaFactory.fix("schemas", next);
+    JsonSchemaFactory.fixPage("schemas", next);
 
     const result: IValidation<IAutoBeInterfaceComplementApplication.IProps> =
       typia.validate<IAutoBeInterfaceComplementApplication.IProps>(next);

package/src/orchestrate/interface/orchestrateInterfaceEndpoints.ts

@@ -5,6 +5,7 @@ import {
   AutoBeProgressEventBase,
 } from "@autobe/interface";
 import { AutoBeInterfaceGroup } from "@autobe/interface/src/histories/contents/AutoBeInterfaceGroup";
+import { AutoBeOpenApiEndpointComparator } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { HashSet, IPointer } from "tstl";
 import typia from "typia";
@@ -16,7 +17,6 @@ import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceEndpointHistories } from "./histories/transformInterfaceEndpointHistories";
 import { orchestrateInterfaceEndpointsReview } from "./orchestrateInterfaceEndpointsReview";
 import { IAutoBeInterfaceEndpointApplication } from "./structures/IAutoBeInterfaceEndpointApplication";
-import { OpenApiEndpointComparator } from "./utils/OpenApiEndpointComparator";
 
 export async function orchestrateInterfaceEndpoints<
   Model extends ILlmSchema.Model,
@@ -50,8 +50,8 @@ export async function orchestrateInterfaceEndpoints<
   ).flat();
   const deduplicated: AutoBeOpenApi.IEndpoint[] = new HashSet(
     endpoints,
-    OpenApiEndpointComparator.hashCode,
-    OpenApiEndpointComparator.equals,
+    AutoBeOpenApiEndpointComparator.hashCode,
+    AutoBeOpenApiEndpointComparator.equals,
   ).toJSON();
   return orchestrateInterfaceEndpointsReview(ctx, deduplicated);
 }
@@ -97,8 +97,8 @@ async function process<Model extends ILlmSchema.Model>(
     id: v7(),
     endpoints: new HashSet(
       pointer.value,
-      OpenApiEndpointComparator.hashCode,
-      OpenApiEndpointComparator.equals,
+      AutoBeOpenApiEndpointComparator.hashCode,
+      AutoBeOpenApiEndpointComparator.equals,
     ).toJSON(),
     tokenUsage,
     created_at: start.toISOString(),

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -4,7 +4,7 @@ import {
   AutoBeOpenApi,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
+import { AutoBeOpenApiEndpointComparator, StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { HashMap, HashSet, IPointer } from "tstl";
 import typia from "typia";
@@ -19,7 +19,6 @@ import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { transformInterfaceOperationHistories } from "./histories/transformInterfaceOperationHistories";
 import { orchestrateInterfaceOperationsReview } from "./orchestrateInterfaceOperationsReview";
 import { IAutoBeInterfaceOperationApplication } from "./structures/IAutoBeInterfaceOperationApplication";
-import { OpenApiEndpointComparator } from "./utils/OpenApiEndpointComparator";
 import { OperationValidator } from "./utils/OperationValidator";
 
 export async function orchestrateInterfaceOperations<
@@ -72,13 +71,13 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const remained: HashSet<AutoBeOpenApi.IEndpoint> = new HashSet(
     props.endpoints,
-    OpenApiEndpointComparator.hashCode,
-    OpenApiEndpointComparator.equals,
+    AutoBeOpenApiEndpointComparator.hashCode,
+    AutoBeOpenApiEndpointComparator.equals,
   );
   const unique: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation> =
     new HashMap(
-      OpenApiEndpointComparator.hashCode,
-      OpenApiEndpointComparator.equals,
+      AutoBeOpenApiEndpointComparator.hashCode,
+      AutoBeOpenApiEndpointComparator.equals,
     );
   for (let i: number = 0; i < ctx.retry; ++i) {
     if (remained.empty() === true || unique.size() >= props.endpoints.length)
@@ -144,6 +143,7 @@ async function process<Model extends ILlmSchema.Model>(
                     .join("/"),
                 authorizationRole: null,
                 authorizationType: null,
+                prerequisites: [],
               },
             ];
           return op.authorizationRoles.map((role) => ({
@@ -155,6 +155,7 @@ async function process<Model extends ILlmSchema.Model>(
                 .join("/"),
             authorizationRole: role,
             authorizationType: null,
+            prerequisites: [],
           }));
         });
         pointer.value.push(...matrix.flat());