@autobe/agent 0.17.1 → 0.18.0

package/src/orchestrate/interface/orchestrateInterfaceSchemas.ts

@@ -1,5 +1,5 @@
-import { IAgenticaController, MicroAgentica } from "@agentica/core";
-import { AutoBeOpenApi } from "@autobe/interface";
+import { IAgenticaController } from "@agentica/core";
+import { AutoBeInterfaceSchemasEvent, AutoBeOpenApi } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
 import { IPointer } from "tstl";
@@ -8,9 +8,9 @@ import typia from "typia";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
-import { enforceToolCall } from "../../utils/enforceToolCall";
-import { forceRetry } from "../../utils/forceRetry";
+import { IProgress } from "../internal/IProgress";
 import { transformInterfaceSchemaHistories } from "./histories/transformInterfaceSchemaHistories";
+import { orchestrateInterfaceSchemasReview } from "./orchestrateInterfaceSchemasReview";
 import { IAutoBeInterfaceSchemaApplication } from "./structures/IAutoBeInterfaceSchemaApplication";
 
 export async function orchestrateInterfaceSchemas<
@@ -29,24 +29,25 @@ export async function orchestrateInterfaceSchemas<
     array: Array.from(typeNames),
     capacity,
   });
-  let progress: number = 0;
-
+  const progress: IProgress = {
+    total: typeNames.size,
+    completed: 0,
+  };
+  const reviewProgress: IProgress = {
+    total: matrix.length,
+    completed: 0,
+  };
   const x: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
   for (const y of await Promise.all(
     matrix.map(async (it) => {
       const row: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-        await divideAndConquer(ctx, operations, it, 3, (count) => {
-          progress += count;
-        });
-      ctx.dispatch({
-        type: "interfaceSchemas",
-        schemas: row,
-        completed: progress,
-        total: typeNames.size,
-        step: ctx.state().analyze?.step ?? 0,
-        created_at: new Date().toISOString(),
-      });
-      return row;
+        await divideAndConquer(ctx, operations, it, 3, progress);
+      return orchestrateInterfaceSchemasReview(
+        ctx,
+        operations,
+        row,
+        reviewProgress,
+      );
     }),
   )) {
     Object.assign(x, y);
@@ -59,20 +60,18 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
   operations: AutoBeOpenApi.IOperation[],
   typeNames: string[],
   retry: number,
-  progress: (completed: number) => void,
+  progress: IProgress,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   const remained: Set<string> = new Set(typeNames);
   const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
   for (let i: number = 0; i < retry; ++i) {
     if (remained.size === 0) break;
-    const before: number = remained.size;
     const newbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-      await forceRetry(() => process(ctx, operations, schemas, remained));
+      await process(ctx, operations, schemas, remained, progress);
     for (const key of Object.keys(newbie)) {
       schemas[key] = newbie[key];
       remained.delete(key);
     }
-    if (before - remained.size !== 0) progress(before - remained.size);
   }
   return schemas;
 }
@@ -82,77 +81,70 @@ async function process<Model extends ILlmSchema.Model>(
   operations: AutoBeOpenApi.IOperation[],
   oldbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
   remained: Set<string>,
+  progress: IProgress,
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
+  const already: string[] = Object.keys(oldbie);
   const pointer: IPointer<Record<
     string,
     AutoBeOpenApi.IJsonSchemaDescriptive
   > | null> = {
     value: null,
   };
-  const agentica: MicroAgentica<Model> = new MicroAgentica({
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...(ctx.config ?? {}),
-      executor: {
-        describe: null,
-      },
-    },
+  const { tokenUsage } = await ctx.conversate({
+    source: "interfaceSchemas",
     histories: transformInterfaceSchemaHistories(ctx.state(), operations),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        build: async (next) => {
-          pointer.value ??= {};
-          Object.assign(pointer.value, next);
-        },
-        pointer,
-      }),
-    ],
+    controller: createController({
+      model: ctx.model,
+      build: async (next) => {
+        pointer.value ??= {};
+        Object.assign(pointer.value, next);
+      },
+      pointer,
+    }),
+    enforceFunctionCall: true,
+    message: [
+      "Make type components please.",
+      "",
+      "Here is the list of request/response bodies' type names from",
+      "OpenAPI operations. Make type components of them. If more object",
+      "types are required during making the components, please make them",
+      "too.",
+      "",
+      ...Array.from(remained).map((k) => `- \`${k}\``),
+      ...(already.length !== 0
+        ? [
+            "",
+            "> By the way, here is the list of components schemas what you've",
+            "> already made. So, you don't need to make them again.",
+            ">",
+            ...already.map((k) => `> - \`${k}\``),
+          ]
+        : []),
+    ].join("\n"),
   });
-  enforceToolCall(agentica);
+  if (pointer.value === null) throw new Error("Failed to create components.");
 
-  const already: string[] = Object.keys(oldbie);
-  await agentica
-    .conversate(
-      [
-        "Make type components please.",
-        "",
-        "Here is the list of request/response bodies' type names from",
-        "OpenAPI operations. Make type components of them. If more object",
-        "types are required during making the components, please make them",
-        "too.",
-        "",
-        ...Array.from(remained).map((k) => `- \`${k}\``),
-        ...(already.length !== 0
-          ? [
-              "",
-              "> By the way, here is the list of components schemas what you've",
-              "> already made. So, you don't need to make them again.",
-              ">",
-              ...already.map((k) => `> - \`${k}\``),
-            ]
-          : []),
-      ].join("\n"),
-    )
-    .finally(() => {
-      const tokenUsage = agentica.getTokenUsage().aggregate;
-      ctx.usage().record(tokenUsage, ["interface"]);
-    });
-  if (pointer.value === null) {
-    // never be happened
-    throw new Error("Failed to create components.");
-  }
-  return (
+  const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
     (
       OpenApiV3_1Emender.convertComponents({
         schemas: pointer.value,
       }) as AutoBeOpenApi.IComponents
-    ).schemas ?? {}
-  );
+    ).schemas ?? {};
+  ctx.dispatch({
+    type: "interfaceSchemas",
+    schemas,
+    tokenUsage,
+    completed: (progress.completed += Object.keys(schemas).filter(
+      (k) => oldbie[k] === undefined,
+    ).length),
+    total: progress.total,
+    step: ctx.state().prisma?.step ?? 0,
+    created_at: new Date().toISOString(),
+  } satisfies AutoBeInterfaceSchemasEvent);
+  return schemas;
 }
 
-function createApplication<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (
     next: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
@@ -166,7 +158,7 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
   const application: ILlmApplication<Model> = collection[
     props.model
-  ] as unknown as ILlmApplication<Model>;
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
     name: "interface",
@@ -181,14 +173,12 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
 const claude = typia.llm.application<
   IAutoBeInterfaceSchemaApplication,
-  "claude",
-  { reference: true }
+  "claude"
 >();
 const collection = {
   chatgpt: typia.llm.application<
     IAutoBeInterfaceSchemaApplication,
-    "chatgpt",
-    { reference: true }
+    "chatgpt"
   >(),
   claude,
   llama: claude,

package/src/orchestrate/interface/orchestrateInterfaceSchemasReview.ts

@@ -0,0 +1,143 @@
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeInterfaceSchemasReviewEvent,
+  AutoBeOpenApi,
+} from "@autobe/interface";
+import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { transformInterfaceSchemasReviewHistories } from "./histories/transformInterfaceSchemasReviewHistories";
+import { IAutoBeInterfaceSchemasReviewApplication } from "./structures/IAutobeInterfaceSchemasReviewApplication";
+
+export async function orchestrateInterfaceSchemasReview<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  operations: AutoBeOpenApi.IOperation[],
+  schemas: Record<
+    string,
+    AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>
+  >,
+  progress: { total: number; completed: number },
+): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
+  const pointer: IPointer<IAutoBeInterfaceSchemasReviewApplication.IProps | null> =
+    {
+      value: null,
+    };
+
+  const { tokenUsage } = await ctx.conversate({
+    source: "interfaceSchemasReview",
+    controller: createController({
+      model: ctx.model,
+      pointer,
+      schemas,
+    }),
+    histories: transformInterfaceSchemasReviewHistories(
+      ctx.state(),
+      operations,
+      schemas,
+    ),
+    enforceFunctionCall: true,
+    message: "Review type schemas.",
+  });
+  if (pointer.value === null)
+    throw new Error("Failed to extract review information.");
+
+  ctx.dispatch({
+    type: "interfaceSchemasReview",
+    schemas: schemas,
+    review: pointer.value.review,
+    plan: pointer.value.plan,
+    content: pointer.value.content,
+    tokenUsage,
+    step: ctx.state().analyze?.step ?? 0,
+    total: progress.total,
+    completed: ++progress.completed,
+    created_at: new Date().toISOString(),
+  } satisfies AutoBeInterfaceSchemasReviewEvent);
+  return pointer.value.content;
+}
+
+function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  pointer: IPointer<IAutoBeInterfaceSchemasReviewApplication.IProps | null>;
+  schemas: Record<
+    string,
+    AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>
+  >;
+}): IAgenticaController.IClass<Model> {
+  const validate = (
+    next: unknown,
+  ): IValidation<IAutoBeInterfaceSchemasReviewApplication.IProps> => {
+    const result: IValidation<IAutoBeInterfaceSchemasReviewApplication.IProps> =
+      typia.validate<IAutoBeInterfaceSchemasReviewApplication.IProps>(next);
+    if (result.success === false) return result;
+
+    const errors: IValidation.IError[] = [];
+    if (Object.keys(result.data.content).length === 0) {
+      console.log();
+      console.log();
+      console.log();
+      console.log(
+        JSON.stringify({ schemas: props.schemas, ...result.data }, null, 2),
+      );
+      errors.push({
+        path: `$input.content`,
+        expected: `Content must not be empty. If it's at a level that can't be fixed, please create a schema instead to meet the requirements.`,
+        value: result.data.content,
+      });
+    }
+
+    if (errors.length > 0) {
+      return {
+        success: false,
+        errors,
+        data: result.data,
+      };
+    }
+
+    return result;
+  };
+
+  const application: ILlmApplication<Model> = collection[
+    props.model === "chatgpt" ? "chatgpt" : "claude"
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+
+  return {
+    protocol: "class",
+    name: "Reviewer",
+    application,
+    execute: {
+      review: (input) => {
+        props.pointer.value = input;
+      },
+    } satisfies IAutoBeInterfaceSchemasReviewApplication,
+  };
+}
+const claude = (validate: Validator) =>
+  typia.llm.application<IAutoBeInterfaceSchemasReviewApplication, "claude">({
+    validate: {
+      review: validate,
+    },
+  });
+
+const collection = {
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceSchemasReviewApplication, "chatgpt">({
+      validate: {
+        review: validate,
+      },
+    }),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeInterfaceSchemasReviewApplication.IProps>;

package/src/orchestrate/interface/structures/IAutoBeInterfaceAuthorizationsApplication.ts

@@ -0,0 +1,49 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { tags } from "typia";
+
+export interface IAutoBeInterfaceAuthorizationsApplication {
+  /**
+   * Creates an authorization Operations for the given roles
+   *
+   * This method generates an OpenAPI interface that defines the authorization
+   * requirements for the given roles. It ensures that the interface reflects
+   * the correct permissions and access levels for each role.
+   */
+  makeOperations(props: IAutoBeInterfaceAuthorizationsApplication.IProps): void;
+}
+
+export namespace IAutoBeInterfaceAuthorizationsApplication {
+  export interface IProps {
+    /**
+     * Array of API operations to generate authorization operation for.
+     *
+     * Each operation in this array must include:
+     *
+     * - Specification: Detailed API specification with clear purpose and
+     *   functionality
+     * - Path: Resource-centric URL path (e.g., "/resources/{resourceId}")
+     * - Method: HTTP method (get, post, put, delete, patch)
+     * - Description: Extremely detailed multi-paragraph description referencing
+     *   Prisma schema comments
+     * - Summary: Concise one-sentence summary of the endpoint
+     * - Parameters: Array of all necessary parameters with descriptions and
+     *   schema definitions
+     * - RequestBody: For POST/PUT/PATCH methods, with typeName referencing
+     *   components.schemas
+     * - ResponseBody: With typeName referencing appropriate response type
+     *
+     * All operations must follow strict quality standards:
+     *
+     * 1. Detailed descriptions referencing Prisma schema comments
+     * 2. Accurate parameter definitions matching path parameters
+     * 3. Appropriate request/response body type references
+     * 4. Consistent patterns for CRUD operations
+     *
+     * For list retrievals (typically PATCH), include pagination, search, and
+     * sorting. For detail retrieval (GET), return a single resource. For
+     * creation (POST), use .ICreate request body. For modification (PUT), use
+     * .IUpdate request body.
+     */
+    operations: AutoBeOpenApi.IOperation[] & tags.MinItems<1>;
+  }
+}

package/src/orchestrate/interface/structures/IAutoBeInterfaceEndpointApplication.ts

@@ -1,4 +1,5 @@
 import { AutoBeOpenApi } from "@autobe/interface";
+import { tags } from "typia";
 
 export interface IAutoBeInterfaceEndpointApplication {
   /**
@@ -19,6 +20,6 @@ export interface IAutoBeInterfaceEndpointApplication {
 export namespace IAutoBeInterfaceEndpointApplication {
   export interface IProps {
     /** The endpoints to generate. */
-    endpoints: AutoBeOpenApi.IEndpoint[];
+    endpoints: AutoBeOpenApi.IEndpoint[] & tags.MinItems<1>;
   }
 }

package/src/orchestrate/interface/structures/IAutoBeInterfaceOperationApplication.ts

@@ -1,4 +1,4 @@
-import { AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeOpenApi, CamelPattern } from "@autobe/interface";
 import { tags } from "typia";
 
 export interface IAutoBeInterfaceOperationApplication {
@@ -96,6 +96,10 @@ export namespace IAutoBeInterfaceOperationApplication {
      * endpoint. Multiple roles can be specified to allow different types of
      * users to access the same endpoint.
      *
+     * ## Naming Convention
+     *
+     * All role names MUST use camelCase.
+     *
      * ## Important Guidelines
      *
      * - Set to empty array `[]` for public endpoints that require no
@@ -120,6 +124,6 @@ export namespace IAutoBeInterfaceOperationApplication {
      * handled by decorators at the controller level, and the provider function
      * will receive the authenticated user object with the appropriate type.
      */
-    authorizationRoles: Array<string & tags.MinLength<1>>;
+    authorizationRoles: Array<string & CamelPattern & tags.MinLength<1>>;
   }
 }

package/src/orchestrate/interface/structures/IAutoBeInterfaceOperationsReviewApplication.ts

@@ -0,0 +1,102 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+/**
+ * Application interface for reviewing and validating API operations.
+ *
+ * Provides functionality to systematically review generated API operations
+ * against business requirements, technical specifications, and OpenAPI
+ * standards. The review process ensures each operation meets quality criteria
+ * before proceeding to implementation.
+ */
+export interface IAutoBeInterfaceOperationsReviewApplication {
+  /**
+   * Reviews a batch of API operations for quality and correctness.
+   *
+   * Validates each operation's request/response schemas, authentication
+   * handling, error responses, and documentation completeness. Operations are
+   * marked as passed or failed based on compliance with enterprise standards.
+   *
+   * @param input Collection of operations to review with their validation
+   *   results
+   */
+  reviewOperations(
+    input: IAutoBeInterfaceOperationsReviewApplication.IProps,
+  ): void;
+}
+
+export namespace IAutoBeInterfaceOperationsReviewApplication {
+  /**
+   * Properties for API operation review and improvement process.
+   *
+   * Contains both the input operations to be reviewed and the outputs generated
+   * by the Interface Operations Review Agent, which will be published as part
+   * of the AutoBeInterfaceOperationsReviewEvent.
+   */
+  export interface IProps {
+    /**
+     * Comprehensive review analysis with prioritized findings.
+     *
+     * Systematic assessment organized by severity levels (CRITICAL, HIGH,
+     * MEDIUM, LOW):
+     *
+     * - **Security Analysis**: Authentication boundary violations, exposed
+     *   passwords/tokens, unauthorized data access patterns, SQL injection
+     *   risks
+     * - **Logic Validation**: Return type consistency (list operations returning
+     *   arrays, single retrieval returning single items), HTTP method semantics
+     *   alignment, parameter usage verification
+     * - **Schema Compliance**: Field existence in Prisma schema, type accuracy,
+     *   relationship validity, required field handling
+     * - **Quality Assessment**: Documentation completeness, naming conventions,
+     *   error handling patterns, pagination standards
+     *
+     * Each finding includes specific examples, current vs expected behavior,
+     * and concrete fix recommendations. Critical security issues and logical
+     * contradictions are highlighted for immediate attention.
+     */
+    review: string;
+
+    /**
+     * Prioritized action plan for identified issues.
+     *
+     * Structured improvement strategy categorized by severity:
+     *
+     * - **Immediate Actions (CRITICAL)**: Security vulnerabilities that must be
+     *   fixed before production (password exposure, missing authorization,
+     *   authentication bypass risks)
+     * - **Required Fixes (HIGH)**: Functional issues affecting API correctness
+     *   (wrong return types, missing required fields, schema mismatches)
+     * - **Recommended Improvements (MEDIUM)**: Quality enhancements for better
+     *   API design (validation rules, format specifications, consistency)
+     * - **Optional Enhancements (LOW)**: Documentation and usability improvements
+     *
+     * If all operations pass review without issues, contains: "No improvements
+     * required. All operations meet AutoBE standards."
+     *
+     * Each action item includes the specific operation path, the exact change
+     * needed, and the rationale for the modification.
+     */
+    plan: string;
+
+    /**
+     * Production-ready operations with all critical issues resolved.
+     *
+     * Final API operations after systematic enhancement:
+     *
+     * - **Security Fixes Applied**: All authentication boundaries enforced,
+     *   sensitive data removed from responses, proper authorization
+     *   implemented
+     * - **Logic Corrections Made**: Return types match operation intent, HTTP
+     *   methods align with semantics, parameters properly utilized
+     * - **Schema Alignment Verified**: All fields exist in Prisma schema, types
+     *   correctly mapped, relationships properly defined
+     * - **Quality Improvements Added**: Enhanced documentation, format
+     *   specifications, validation rules, consistent naming patterns
+     *
+     * If no issues were found during review, this contains the exact original
+     * operations unchanged. These operations are validated and ready for schema
+     * generation and subsequent implementation phases.
+     */
+    content: AutoBeOpenApi.IOperation[];
+  }
+}

package/src/orchestrate/interface/structures/IAutobeInterfaceSchemasReviewApplication.ts

@@ -0,0 +1,98 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+export interface IAutoBeInterfaceSchemasReviewApplication {
+  /**
+   * Analyzes and improves OpenAPI schema definitions.
+   *
+   * This function receives schema definitions and performs comprehensive review
+   * and enhancement. It identifies issues, creates an improvement plan, and
+   * produces refined schemas that meet quality standards.
+   *
+   * The function populates three key outputs:
+   *
+   * - A detailed review of findings organized by severity
+   * - An actionable plan for improvements
+   * - Enhanced schemas with all issues resolved
+   *
+   * @param props Contains review findings, improvement plan, and enhanced
+   *   schemas
+   */
+  review: (props: IAutoBeInterfaceSchemasReviewApplication.IProps) => void;
+}
+
+export namespace IAutoBeInterfaceSchemasReviewApplication {
+  /**
+   * Schema review and enhancement parameters for the review function.
+   *
+   * When the review function is called, these properties must be populated to
+   * complete the schema validation and improvement process. The LLM uses this
+   * interface to understand what outputs are required.
+   */
+  export interface IProps {
+    /**
+     * Issues and problems found during schema analysis.
+     *
+     * IMPORTANT: Only document problems that need fixing. Do NOT include:
+     *
+     * - Positive feedback about what's already correct
+     * - Compliments about well-structured schemas
+     * - Confirmation that certain aspects meet standards
+     *
+     * Focus exclusively on issues organized by severity:
+     *
+     * - CRITICAL: Security vulnerabilities (exposed passwords, missing auth
+     *   boundaries)
+     * - HIGH: Missing required variants, incorrect type mappings
+     * - MEDIUM: Missing format specifications, incomplete relationships
+     * - LOW: Documentation improvements, style consistency
+     *
+     * Each issue must include the specific schema name and what needs to be
+     * fixed. If there are no issues at all, simply state: "No issues found."
+     */
+    review: string;
+
+    /**
+     * Action plan for addressing identified issues.
+     *
+     * Must specify concrete fixes categorized by priority:
+     *
+     * - For perfect schemas: "No improvements required. All schemas meet AutoBE
+     *   standards."
+     * - For fixable issues: List each fix with operation path and exact change
+     * - For critical problems: Describe how schemas were recreated or corrected
+     *
+     * Never leave this empty. Always provide a clear plan even if no changes
+     * are needed. The plan documents what was done to produce the content
+     * field.
+     */
+    plan: string;
+
+    /**
+     * Final validated and enhanced schemas ready for production use.
+     *
+     * CRITICAL REQUIREMENTS:
+     *
+     * - MUST NEVER be an empty object {}
+     * - MUST contain valid OpenAPI schema definitions
+     * - MUST include all entities that were in the original input
+     * - If original schemas have critical issues, MUST contain fixed versions
+     * - If entity names are wrong, MUST contain renamed correct versions
+     * - If schemas are missing variants, MUST include the created variants
+     *
+     * FORBIDDEN:
+     *
+     * - Empty object {} will cause all schemas to be deleted
+     * - Returning undefined or null
+     * - Including explanations or excuses in schema descriptions
+     * - Leaving broken schemas unfixed
+     *
+     * When original schemas are beyond repair, recreate them properly based on
+     * entity names and context. This field becomes the final schemas used by
+     * the system, so it must always contain complete, valid schemas.
+     */
+    content: Record<
+      string,
+      AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>
+    >;
+  }
+}

package/src/orchestrate/internal/IProgress.ts

@@ -0,0 +1,4 @@
+export interface IProgress {
+  total: number;
+  completed: number;
+}