@autobe/agent 0.26.0 → 0.28.0

package/src/orchestrate/analyze/orchestrateAnalyzeWrite.ts

@@ -28,7 +28,7 @@ export const orchestrateAnalyzeWrite = async <Model extends ILlmSchema.Model>(
   const pointer: IPointer<IAutoBeAnalyzeWriteApplication.IProps | null> = {
     value: null,
   };
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: "analyzeWrite",
     controller: createController<Model>({
       model: ctx.model,
@@ -49,7 +49,8 @@ export const orchestrateAnalyzeWrite = async <Model extends ILlmSchema.Model>(
       ...file,
       content: pointer.value.content,
     },
-    tokenUsage: tokenUsage,
+    tokenUsage,
+    metric,
     step: (ctx.state().analyze?.step ?? -1) + 1,
     total: progress.total,
     completed: ++progress.completed,
@@ -65,7 +66,11 @@ function createController<Model extends ILlmSchema.Model>(props: {
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
   const application: ILlmApplication<Model> = collection[
-    props.model
+    props.model === "chatgpt"
+      ? "chatgpt"
+      : props.model === "gemini"
+        ? "gemini"
+        : "claude"
   ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
@@ -79,14 +84,8 @@ function createController<Model extends ILlmSchema.Model>(props: {
   };
 }
 
-const claude = typia.llm.application<
-  IAutoBeAnalyzeWriteApplication,
-  "claude"
->();
 const collection = {
   chatgpt: typia.llm.application<IAutoBeAnalyzeWriteApplication, "chatgpt">(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
+  claude: typia.llm.application<IAutoBeAnalyzeWriteApplication, "claude">(),
+  gemini: typia.llm.application<IAutoBeAnalyzeWriteApplication, "gemini">(),
 };

package/src/orchestrate/analyze/structures/IAutoBeAnalyzeReviewApplication.ts

@@ -1,24 +1,11 @@
 export interface IAutoBeAnalyzeReviewApplication {
   /**
-   * Enhances planning documentation to meet all quality standards and requirements.
+   * Enhances and finalizes planning documentation.
    *
-   * This function receives a document and outputs an improved version directly.
-   * The output IS the enhanced document itself, NOT review comments or feedback.
+   * Receives a draft document and outputs the improved version. The output is
+   * the enhanced document itself, not review comments.
    *
-   * The enhancement process includes:
-   * - Expanding sections that are too brief
-   * - Converting vague statements to specific EARS format requirements
-   * - Fixing Mermaid diagram syntax errors
-   * - Adding missing business processes and workflows
-   * - Ensuring proper document structure and completeness
-   *
-   * DO: Output the actual document content that will be saved.
-   * DO NOT: Output review comments or analysis of the document.
-   * 
-   * Note: Any text output becomes part of the final document.
-   *
-   * @param props - The properties containing the document to enhance along with
-   *   plan and review criteria for guidance
+   * @param props - Document content, plan, and review criteria
    */
   review(props: IAutoBeAnalyzeReviewApplication.IProps): void;
 }
@@ -27,7 +14,7 @@ export namespace IAutoBeAnalyzeReviewApplication {
   export interface IProps {
     /**
      * Step 1 (CoT: Review Phase) - Enhancement Criteria
-     * 
+     *
      * The enhancement criteria and guidelines that the agent must follow.
      *
      * This includes:
@@ -48,14 +35,16 @@ export namespace IAutoBeAnalyzeReviewApplication {
      * - DO NOT: Use spaces between brackets and quotes in Mermaid
      * - DO: Make requirements specific and measurable in natural language
      * - DO: Focus on business requirements and user scenarios
-     * - DO NOT: Accept documents containing database schemas or API specifications
-     * - DO: Describe business model and authentication requirements in natural language
+     * - DO NOT: Accept documents containing database schemas or API
+     *   specifications
+     * - DO: Describe business model and authentication requirements in natural
+     *   language
      */
     review: string;
 
     /**
      * Step 2 (CoT: Plan Phase) - Original Document Plan
-     * 
+     *
      * The document plan that was used to create the content.
      *
      * This helps the reviewer understand:
@@ -71,43 +60,19 @@ export namespace IAutoBeAnalyzeReviewApplication {
     plan: string;
 
     /**
-     * Step 3 (CoT: Content Phase) - Complete Document Content
-     * 
-     * The actual markdown document content that incorporates review feedback.
+     * Step 3 (CoT: Content Phase) - Document Content (INPUT → OUTPUT)
      *
-     * This field contains a COMPLETE MARKDOWN DOCUMENT that has already 
-     * incorporated the review criteria and plan requirements.
-     * 
-     * DO: Treat this as the final, production-ready document.
-     * DO NOT: Treat this as raw input to be reviewed.
-     * 
-     * This content represents:
-     * - A fully-formed markdown document (.md file)
-     * - The result of applying review criteria to the original plan
-     * - A production-ready document for immediate deployment
-     * - Complete business requirements ready for developers
-     * 
-     * The enhancer should treat this as the actual document content:
+     * INPUT: The document written by Write Agent (may have issues) OUTPUT: The
+     * enhanced, complete markdown document to be saved
      *
-     * - Length and completeness (minimum 2,000 characters, more for technical
-     *   docs)
-     * - All sections from the plan are fully written
-     * - No vague or abstract statements
-     * - Proper use of EARS format for requirements
-     * - Correct Mermaid diagram syntax (double quotes mandatory)
-     * - Appropriate level of detail for backend implementation
-     * - Proper document linking (descriptive text, not raw filenames)
+     * Enhancement requirements:
      *
-     * The enhancer outputs the document itself:
+     * - Fix Mermaid syntax errors (add quotes, fix arrows)
+     * - Convert vague statements to EARS format
+     * - Expand sections that are too brief
+     * - Add missing business processes
      *
-     * - If content is provided, it represents the actual document
-     * - The enhancer outputs the enhanced version AS the document itself
-     * - No meta-commentary or review feedback should be in the output
-     * - The output becomes the saved .md file directly
-     * 
-     * Example of what this field contains:
-     * "# Service Overview\n## Vision\nThe service provides..." (actual document)
-     * NOT: "This document should cover service overview..." (review comment)
+     * Output must be the actual document content (not review comments).
      */
     content: string;
   }

package/src/orchestrate/analyze/structures/IAutoBeAnalyzeScenarioApplication.ts

@@ -4,18 +4,12 @@ import { tags } from "typia";
 
 export interface IAutoBeAnalyzeScenarioApplication {
   /**
-   * Compose project structure with actors and files.
+   * Composes project structure with actors and documentation files.
    *
-   * Design a list of actors and initial documents that you need to create for
-   * that requirement. Actors define user types and their responsibilities, while files
-   * define the documentation structure. These are managed separately. If you
-   * determine from the conversation that the user's requirements have not been
-   * fully gathered, you must stop the analysis and continue collecting the
-   * remaining requirements. In this case, you do not need to generate any files
-   * or actors. Simply pass an empty array to `input.files` and `input.actors`.
+   * Determines the list of user actors and documents to generate based on
+   * requirements. If requirements are incomplete, returns empty arrays.
    *
-   * @param input Prefix, actors, and files
-   * @returns
+   * @param input - Project prefix, actors, and file list
    */
   compose(input: IAutoBeAnalyzeScenarioApplication.IProps): void;
 }
@@ -33,7 +27,15 @@ export namespace IAutoBeAnalyzeScenarioApplication {
      */
     prefix: string & CamelCasePattern;
 
-    /** Actors to be assigned for the project */
+    /**
+     * Actors to be assigned for the project.
+     *
+     * Each actor has:
+     *
+     * - `name`: Actor identifier (camelCase)
+     * - `kind`: "guest" | "member" | "admin"
+     * - `description`: Actor's permissions and capabilities
+     */
     actors: AutoBeAnalyzeActor[];
 
     /**
@@ -53,12 +55,14 @@ export namespace IAutoBeAnalyzeScenarioApplication {
     page: number;
 
     /**
-     * # Document files to be generated
-     *
-     * File name must be English and it must contain the numbering and prefix.
+     * Array of document metadata objects defining files to be generated.
      *
-     * These files represent business documentation that may include:
+     * Each array element is an AutoBeAnalyzeFile.Scenario object containing:
+     * - filename: The output file name (e.g., "01-service-overview.md")
+     * - reason: Why this document is being created
+     * - documentType, outline, constraints, etc.: Metadata guiding content generation
      *
+     * These documents represent business-focused planning documentation:
      * - Business requirements and functional specifications in natural language
      * - User journey mapping and use case scenarios
      * - Business rules and workflow definitions
@@ -68,17 +72,16 @@ export namespace IAutoBeAnalyzeScenarioApplication {
      * - DO NOT: Include database schemas, ERD, or API specifications
      * - DO: Write all requirements in natural language for clarity
      *
-     * Generate files based on actual requirements gathered from conversation.
+     * Generate metadata objects based on actual requirements gathered from conversation.
      * Do not create unnecessary documentation - only generate what is needed to
      * properly define the business requirements and system specifications.
      *
-     * # Page Length Rules
+     * # Array Length Rules
      *
-     * The number of documents must match the user's request, excluding the
-     * table of contents. For example, if the user requests 3 pages, a total of
-     * 4 documents should be generated, including the table of contents. If the
-     * user does not specify a number, generate a sufficient number of documents
-     * to adequately support the service.
+     * The array length must match the user's requested page count plus one for ToC.
+     * For example: user requests 3 pages → generate 4 objects (1 ToC + 3 content).
+     * If user does not specify a number, generate sufficient objects to adequately
+     * document the service (typically 11+ objects including ToC).
      */
     files: Array<AutoBeAnalyzeFile.Scenario> & tags.MinItems<1>;
   }

package/src/orchestrate/analyze/structures/IAutoBeAnalyzeWriteApplication.ts

@@ -16,7 +16,7 @@ export namespace IAutoBeAnalyzeWriteApplication {
   export interface IProps {
     /**
      * Step 1 (CoT: Plan Phase) - Document Planning Structure
-     * 
+     *
      * The document planning structure that outlines what needs to be written.
      *
      * This includes:
@@ -42,33 +42,17 @@ export namespace IAutoBeAnalyzeWriteApplication {
     plan: string;
 
     /**
-     * Step 2 (CoT: Write Phase) - Document Content Creation
-     * 
-     * The initial content or context for the document being written.
-     *
-     * This may include:
-     *
-     * - User requirements and business goals
-     * - Existing documentation to build upon
-     * - Specific scenarios or use cases to document
-     * - Technical constraints or preferences
-     * - Related documents for reference
+     * Step 2 (CoT: Write Phase) - Complete Document Content
      *
-     * The content provides the raw material that the AI agent will transform
-     * into structured, developer-ready documentation following the planning
-     * guidelines.
+     * The complete, production-ready markdown document content to be saved.
      *
-     * The AI agent will expand this content into comprehensive documentation
-     * that:
+     * Requirements:
      *
-     * - Removes all ambiguity for backend developers
-     * - Provides specific, measurable requirements in natural language
-     * - Focuses on business logic and requirements, NOT technical implementation
-     * - STRICTLY PROHIBITED: Do NOT write database schemas, ERD, or API
-     *   specifications
+     * - Minimum 5,000 characters for technical documents
      * - Uses EARS format for all applicable requirements
-     * - Follows proper document linking conventions
-     * - Includes Mermaid diagrams with proper syntax (double quotes mandatory)
+     * - Includes proper Mermaid diagram syntax (double quotes for labels)
+     * - Focuses on business requirements in natural language
+     * - PROHIBITED: Database schemas, ERD, API specifications
      */
     content: string;
   }

package/src/orchestrate/common/orchestrateCommonCorrectCasting.ts

@@ -1,4 +1,5 @@
 import {
+  AutoBeFunctionCallingMetric,
   AutoBeRealizeCorrectEvent,
   AutoBeRealizeValidateEvent,
   AutoBeTestCorrectEvent,
@@ -33,6 +34,7 @@ interface IFactoryProps<
     draft: string;
     review: string | undefined;
     final: string | undefined;
+    metric: AutoBeFunctionCallingMetric;
     tokenUsage: IAutoBeTokenUsageJson.IComponent;
   }): CorrectEvent;
   script(event: ValidateEvent): string;
@@ -92,7 +94,7 @@ const correct = async <
   > = {
     value: null,
   };
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: factory.source,
     histories: transformCommonCorrectCastingHistories(
       [...failures, event].map((e) => ({
@@ -115,7 +117,7 @@ const correct = async <
     message: StringUtil.trim`
       Fix the TypeScript casting problems to resolve the compilation error.
 
-      You don't need to explain me anything, but just fix or give it up 
+      You don't need to explain me anything, but just fix or give it up
       immediately without any hesitation, explanation, and questions.
     `,
   });
@@ -129,6 +131,7 @@ const correct = async <
       draft: pointer.value.draft,
       review: pointer.value.revise.review,
       final: pointer.value.revise.final ?? undefined,
+      metric,
       tokenUsage,
     }),
   );
@@ -167,7 +170,11 @@ const createController = <Model extends ILlmSchema.Model>(props: {
       : result;
   };
   const application = collection[
-    props.model === "chatgpt" ? "chatgpt" : "claude"
+    props.model === "chatgpt"
+      ? "chatgpt"
+      : props.model === "gemini"
+        ? "gemini"
+        : "claude"
   ](validate) satisfies ILlmApplication<any> as any as ILlmApplication<Model>;
   return {
     protocol: "class",
@@ -205,6 +212,16 @@ const collection = {
         }),
       },
     }),
+  gemini: (validate: Validator) =>
+    typia.llm.application<IAutoBeCommonCorrectCastingApplication, "gemini">({
+      validate: {
+        rewrite: validate,
+        reject: () => ({
+          success: true,
+          data: undefined,
+        }),
+      },
+    }),
 };
 
 type Validator = (

package/src/orchestrate/facade/createAutoBeFacadeController.ts

@@ -0,0 +1,136 @@
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeAnalyzeHistory,
+  AutoBeAssistantMessageEvent,
+  AutoBeAssistantMessageHistory,
+  AutoBeInterfaceHistory,
+  AutoBePrismaHistory,
+  AutoBeRealizeHistory,
+  AutoBeTestHistory,
+} from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import typia from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { orchestrateAnalyze } from "../analyze/orchestrateAnalyze";
+import { orchestrateInterface } from "../interface/orchestrateInterface";
+import { orchestratePrisma } from "../prisma/orchestratePrisma";
+import { orchestrateRealize } from "../realize/orchestrateRealize";
+import { orchestrateTest } from "../test/orchestrateTest";
+import { IAutoBeFacadeApplication } from "./histories/IAutoBeFacadeApplication";
+
+export const createAutoBeFacadeController = <
+  Model extends ILlmSchema.Model,
+>(props: {
+  model: Model;
+  context: AutoBeContext<Model>;
+}): IAgenticaController.IClass<Model> => {
+  assertSchemaModel(props.model);
+  const application: ILlmApplication<Model> = collection[
+    props.model === "chatgpt"
+      ? "chatgpt"
+      : props.model === "gemini"
+        ? "gemini"
+        : "claude"
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "autobe",
+    application,
+    execute: {
+      analyze: async () => {
+        const history: AutoBeAssistantMessageHistory | AutoBeAnalyzeHistory =
+          await orchestrateAnalyze(props.context);
+        if (history.type === "assistantMessage")
+          return {
+            type: "in-progress",
+            description: StringUtil.trim`
+              Requirements are not yet fully elicited, 
+              therefore additional questions will be made to the user.
+            `,
+          };
+        return {
+          type: "success",
+          description:
+            "Analysis completed successfully, and report has been published.",
+        };
+      },
+      prisma: async (next) => {
+        const history: AutoBeAssistantMessageHistory | AutoBePrismaHistory =
+          await orchestratePrisma(props.context, next);
+        if (history.type === "assistantMessage")
+          return {
+            type: "prerequisites-not-satisfied",
+            description: "Requirement analysis is not yet completed.",
+          };
+        return {
+          type: history.compiled.type,
+          description:
+            history.compiled.type === "success"
+              ? "Prisma schemas have been generated successfully."
+              : history.result.success === false ||
+                  history.compiled.type === "failure"
+                ? "Prisma schemas are generated, but compilation failed."
+                : "Unexpected error occurred while generating Prisma schemas.",
+        };
+      },
+      interface: async (next) => {
+        const history: AutoBeAssistantMessageEvent | AutoBeInterfaceHistory =
+          await orchestrateInterface(props.context)(next);
+        if (history.type === "assistantMessage")
+          return {
+            type: "prerequisites-not-satisfied",
+            description: "Prisma schemas are not yet completed.",
+          };
+        return {
+          type: "success",
+          description: "API interfaces have been designed successfully.",
+        };
+      },
+      test: async (next) => {
+        const history: AutoBeAssistantMessageHistory | AutoBeTestHistory =
+          await orchestrateTest(props.context)(next);
+        if (history.type === "assistantMessage")
+          return {
+            type: "prerequisites-not-satisfied",
+            description: "API interfaces are not yet completed.",
+          };
+        return {
+          type: history.compiled.type,
+          description:
+            history.compiled.type === "success"
+              ? "Test functions have been generated successfully."
+              : history.compiled.type === "failure"
+                ? "Test functions are written, but compilation failed."
+                : "Unexpected error occurred while writing test functions.",
+        };
+      },
+      realize: async (next) => {
+        const history: AutoBeAssistantMessageHistory | AutoBeRealizeHistory =
+          await orchestrateRealize(props.context)(next);
+        if (history.type === "assistantMessage")
+          return {
+            type: "prerequisites-not-satisfied",
+            description: "API interfaces are not yet completed.",
+          };
+        return {
+          type: history.compiled.type,
+          description:
+            history.compiled.type === "success"
+              ? "API implementation codes have been generated successfully."
+              : history.compiled.type === "failure"
+                ? "Implementation codes are composed, but compilation failed."
+                : "Unexpected error occurred while writing implementation codes.",
+        };
+      },
+    } satisfies IAutoBeFacadeApplication,
+  };
+};
+
+const collection = {
+  chatgpt: typia.llm.application<IAutoBeFacadeApplication, "chatgpt">(),
+  claude: typia.llm.application<IAutoBeFacadeApplication, "claude">(),
+  gemini: typia.llm.application<IAutoBeFacadeApplication, "gemini">(),
+};

package/src/orchestrate/facade/{transformFacadeStateMessage.ts → structures/transformFacadeStateMessage.ts}

@@ -1,7 +1,7 @@
 import { StringUtil } from "@autobe/utils";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../context/AutoBeState";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
 
 export function transformFacadeStateMessage(state: AutoBeState): string {
   const currentState: ICurrentState = getCurrentState(state);

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

@@ -24,6 +24,7 @@ export const transformInterfaceEndpointsReviewHistories = (
     type: "assistantMessage",
     text: [
       "Below are endpoints generated by your request.",
+      "",
       "```json",
       JSON.stringify(endpoints),
       "```",

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -5,6 +5,7 @@ import {
   AutoBeInterfaceGroupEvent,
   AutoBeInterfaceHistory,
   AutoBeOpenApi,
+  AutoBeProgressEventBase,
 } from "@autobe/interface";
 import { AutoBeInterfacePrerequisite } from "@autobe/interface/src/histories/contents/AutoBeInterfacePrerequisite";
 import {
@@ -16,10 +17,11 @@ import { ILlmSchema } from "@samchon/openapi";
 import { HashMap, Pair } from "tstl";
 import { v7 } from "uuid";
 
+import { AutoBeConfigConstant } from "../../constants/AutoBeConfigConstant";
 import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeFacadeApplicationProps } from "../../context/IAutoBeFacadeApplicationProps";
 import { predicateStateMessage } from "../../utils/predicateStateMessage";
+import { IAutoBeFacadeApplicationProps } from "../facade/histories/IAutoBeFacadeApplicationProps";
 import { orchestrateInterfaceAuthorizations } from "./orchestrateInterfaceAuthorizations";
 import { orchestrateInterfaceComplement } from "./orchestrateInterfaceComplement";
 import { orchestrateInterfaceEndpoints } from "./orchestrateInterfaceEndpoints";
@@ -130,19 +132,26 @@ export const orchestrateInterface =
       );
     await complement();
 
+    const reviewProgress: AutoBeProgressEventBase = {
+      completed: 0,
+      total: Math.ceil(
+        Object.keys(document.components.schemas).length /
+          AutoBeConfigConstant.INTERFACE_CAPACITY,
+      ),
+    };
     for (const config of [
       {
-        type: "interfaceSchemaSecurityReview" as const,
+        kind: "security" as const,
         systemPrompt:
           AutoBeSystemPromptConstant.INTERFACE_SCHEMA_SECURITY_REVIEW,
       },
       {
-        type: "interfaceSchemaRelationReview" as const,
+        kind: "relation" as const,
         systemPrompt:
           AutoBeSystemPromptConstant.INTERFACE_SCHEMA_RELATION_REVIEW,
       },
       {
-        type: "interfaceSchemaContentReview" as const,
+        kind: "content" as const,
         systemPrompt:
           AutoBeSystemPromptConstant.INTERFACE_SCHEMA_CONTENT_REVIEW,
       },
@@ -151,6 +160,7 @@ export const orchestrateInterface =
         await orchestrateInterfaceSchemaReview(ctx, config, {
           instruction: props.instruction,
           document,
+          progress: reviewProgress,
         }),
       );
     if (missedOpenApiSchemas(document).length !== 0) await complement();
@@ -181,8 +191,9 @@ export const orchestrateInterface =
       document,
       missed: missedOpenApiSchemas(document),
       authorizations,
-      created_at: new Date().toISOString(),
-      elapsed: new Date().getTime() - start.getTime(),
+      aggregates: ctx.getCurrentAggregates("interface"),
       step: ctx.state().analyze?.step ?? 0,
+      elapsed: new Date().getTime() - start.getTime(),
+      created_at: new Date().toISOString(),
     } satisfies AutoBeInterfaceCompleteEvent);
   };

package/src/orchestrate/interface/orchestrateInterfaceAuthorizations.ts

@@ -62,7 +62,7 @@ async function process<Model extends ILlmSchema.Model>(
     {
       value: null,
     };
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: "interfaceAuthorization",
     histories: transformInterfaceAuthorizationsHistories({
       state: ctx.state(),
@@ -88,6 +88,7 @@ async function process<Model extends ILlmSchema.Model>(
     id: v7(),
     operations: pointer.value.operations,
     completed: ++props.progress.completed,
+    metric,
     tokenUsage,
     created_at: new Date().toISOString(),
     step: ctx.state().analyze?.step ?? 0,
@@ -195,7 +196,11 @@ function createController<Model extends ILlmSchema.Model>(props: {
   };
 
   const application: ILlmApplication<Model> = collection[
-    props.model === "chatgpt" ? "chatgpt" : "claude"
+    props.model === "chatgpt"
+      ? "chatgpt"
+      : props.model === "gemini"
+        ? "gemini"
+        : "claude"
   ](
     validate,
   ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
@@ -227,6 +232,12 @@ const collection = {
         makeOperations: validate,
       },
     }),
+  gemini: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceAuthorizationsApplication, "gemini">({
+      validate: {
+        makeOperations: validate,
+      },
+    }),
 };
 
 type Validator = (

package/src/orchestrate/interface/orchestrateInterfaceComplement.ts

@@ -50,7 +50,7 @@ async function step<Model extends ILlmSchema.Model>(
   > | null> = {
     value: null,
   };
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: "interfaceComplement",
     histories: transformInterfaceComplementHistories({
       state: ctx.state(),
@@ -86,6 +86,7 @@ async function step<Model extends ILlmSchema.Model>(
     id: v7(),
     missed,
     schemas: pointer.value,
+    metric,
     tokenUsage,
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
@@ -155,7 +156,11 @@ function createController<Model extends ILlmSchema.Model>(props: {
   };
 
   const application: ILlmApplication<Model> = collection[
-    props.model === "chatgpt" ? "chatgpt" : "claude"
+    props.model === "chatgpt"
+      ? "chatgpt"
+      : props.model === "gemini"
+        ? "gemini"
+        : "claude"
   ](
     validate,
   ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
@@ -184,6 +189,12 @@ const collection = {
         complementComponents: validate,
       },
     }),
+  gemini: (validate: Validator) =>
+    typia.llm.application<IAutoBeInterfaceComplementApplication, "gemini">({
+      validate: {
+        complementComponents: validate,
+      },
+    }),
 };
 
 type Validator = (