@autobe/agent 0.17.1 → 0.19.1

package/lib/interface/src/histories/contents/AutoBeAnalyzeFile.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Interface representing a planning document file structure used by the Analyze
+ * Agent in the AutoBE system.
+ *
+ * This interface defines the complete metadata and content structure for
+ * documentation generated during the requirements analysis phase. The Analyze
+ * Agent uses this structure to create comprehensive planning documents that
+ * serve as blueprints for backend developers implementing the system.
+ *
+ * The documents created using this interface follow a waterfall model approach,
+ * where each document builds upon previous ones to form a complete
+ * specification before any code is written. These documents are designed to
+ * remove all ambiguity and provide developers with actionable, specific
+ * requirements.
+ *
+ * Key characteristics:
+ *
+ * - Single-pass document creation (no iterations or revisions)
+ * - Production-ready specifications on first write
+ * - Backend-focused content (no frontend UI/UX requirements)
+ * - Minimum 2,000 characters for standard docs, 5,000-30,000+ for technical
+ * - Uses EARS (Easy Approach to Requirements Syntax) format
+ * - Includes comprehensive API specifications (40-50+ endpoints for complex
+ *   systems)
+ * - Complete database schemas and business logic
+ *
+ * @author Kakasoo
+ * @since 0.1.0
+ * @see IAutoBeAnalyzeWriteApplication - The application interface that uses this structure
+ * @see AutoBeAnalyzeScenarioEvent - Event structure for multi-document scenarios
+ * @see AutoBeAnalyzeRole - User role definitions used in authentication planning
+ */
+export interface AutoBeAnalyzeFile extends AutoBeAnalyzeFile.Scenario {
+    /**
+     * Markdown file content. Only write the content of the file. Do not include
+     * any questions. This should contain only the contents of the file. Do not
+     * write down any questions or appreciation. For example, remove a sentence
+     * such as "Is it okay if we proceed with the table of contents? Please let me
+     * know if there is anything to add or exclude from the table of contents!"
+     *
+     * PROHIBITED content in markdown:
+     *
+     * - Questions to the reader (e.g., "Is there anything else to refine?")
+     * - Feedback requests (e.g., "Please review and let me know")
+     * - Interactive elements expecting responses
+     * - Meta-commentary about the document writing process
+     *
+     * The markdown must be a complete, standalone deliverable without any
+     * conversational elements. If clarification is needed, it should be requested
+     * outside the document content.
+     */
+    content: string;
+}
+export declare namespace AutoBeAnalyzeFile {
+    interface Scenario {
+        /**
+         * Describe briefly why you made this document, and if you have any plans
+         * for the next one. This helps maintain context between documents and
+         * ensures a logical flow in documentation creation. Example: "To define the
+         * core features and user needs for the e-commerce platform before moving on
+         * to detailed user flow documentation."
+         */
+        reason: string;
+        /**
+         * Filename to generate or overwrite. Should be descriptive and follow a
+         * consistent naming convention. Examples: "01-service-overview.md",
+         * "02-user-requirements.md", "03-business-model.md"
+         */
+        filename: `${string}.md`;
+        /**
+         * Document type that determines the structure and content guidelines. This
+         * helps the AI understand what kind of document to create and what sections
+         * or information should be included. Examples:
+         *
+         * - "requirement": Functional/non-functional requirements, acceptance
+         *   criteria
+         * - "user-story": User personas, scenarios, and journey descriptions
+         * - "user-flow": Step-by-step user interactions and decision points
+         * - "business-model": Revenue streams, cost structure, value propositions
+         * - "service-overview": High-level service description, goals, and scope
+         */
+        documentType?: string;
+        /**
+         * Outline or table of contents that guides the document structure. Each
+         * item represents a main section to be covered in the document. The AI will
+         * expand each section with appropriate content while maintaining the
+         * specified structure. Example: ["Executive Summary", "Problem Statement",
+         * "Target Users", "Core Features", "Success Metrics", "Implementation
+         * Timeline"]
+         */
+        outline?: string[];
+        /**
+         * Target audience for this document. Determines the language, technical
+         * depth, and focus areas of the content. If not specified, the document
+         * will be written for a general audience with balanced technical and
+         * business perspectives. Examples:
+         *
+         * - "development team": More technical details, implementation considerations
+         * - "business stakeholders": Focus on ROI, business value, market opportunity
+         * - "end users": User-friendly language, benefits, and use cases
+         * - "product managers": Balance of user needs, business goals, and
+         *   feasibility
+         * - "general": Accessible to all stakeholders (default if not specified)
+         */
+        audience?: string;
+        /**
+         * Key questions or concerns this document should address. Helps ensure the
+         * document covers all important aspects and doesn't miss critical
+         * information. The AI will make sure to answer these questions within the
+         * document content. Examples:
+         *
+         * - "What problem does this service solve?"
+         * - "Who are the primary and secondary users?"
+         * - "What are the main competitive advantages?"
+         * - "How will we measure success?"
+         * - "What are the potential risks and mitigation strategies?"
+         */
+        keyQuestions?: string[];
+        /**
+         * Level of detail expected in the document. Guides how deeply the AI should
+         * explore each topic and how much information to include. Examples:
+         *
+         * - "high-level overview": Brief, conceptual, focusing on the big picture
+         * - "detailed specification": Comprehensive, with specific examples and edge
+         *   cases
+         * - "executive summary": Concise, focusing on key points and decisions
+         * - "moderate detail": Balanced approach with essential details (default)
+         */
+        detailLevel?: string;
+        /**
+         * Related documents that this document references or builds upon. Helps
+         * maintain consistency across documentation and allows the AI to understand
+         * the broader context. These documents should already exist or be planned
+         * in the documentation roadmap. Examples: ["00-project-charter.md",
+         * "01-market-analysis.md", "02-competitor-research.md"]
+         */
+        relatedDocuments?: string[];
+        /**
+         * Specific constraints or requirements for the document. These are
+         * must-have elements or considerations that should be included regardless
+         * of other factors. The AI will ensure these constraints are met.
+         * Examples:
+         *
+         * - "Must include cost-benefit analysis"
+         * - "Focus on mobile-first user experience"
+         * - "Include measurable KPIs and success metrics"
+         * - "Address data privacy and security concerns"
+         * - "Consider scalability for 1M+ users"
+         * - "Include timeline and milestone recommendations"
+         */
+        constraints?: string[];
+    }
+}

package/lib/interface/src/histories/contents/AutoBeAnalyzeFile.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AutoBeAnalyzeFile.js.map

package/lib/interface/src/histories/contents/AutoBeAnalyzeFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutoBeAnalyzeFile.js","sourceRoot":"","sources":["../../../../../../interface/src/histories/contents/AutoBeAnalyzeFile.ts"],"names":[],"mappings":""}

package/lib/orchestrate/analyze/histories/transformAnalyzeReviewerHistories.d.ts

@@ -0,0 +1,6 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeScenarioEvent } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+export declare const transformAnalyzeReviewerHistories: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, scenario: AutoBeAnalyzeScenarioEvent, otherFiles: AutoBeAnalyzeFile[], myFile: AutoBeAnalyzeFile) => Array<IAgenticaHistoryJson.IUserMessage | IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/analyze/histories/transformAnalyzeScenarioHistories.d.ts

@@ -0,0 +1,4 @@
+import { IMicroAgenticaHistoryJson } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+export declare function transformAnalyzeSceHistories<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>): Array<IMicroAgenticaHistoryJson>;

package/lib/orchestrate/analyze/histories/transformAnalyzeWriteHistories.d.ts

@@ -0,0 +1,6 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeScenarioEvent } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+export declare const transformAnalyzeWriteHistories: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, scenario: AutoBeAnalyzeScenarioEvent, file: AutoBeAnalyzeFile.Scenario) => Array<IAgenticaHistoryJson.IUserMessage | IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/analyze/orchestrateAnalyze.d.ts

@@ -2,5 +2,4 @@ import { AutoBeAnalyzeHistory, AutoBeAssistantMessageHistory } from "@autobe/int
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
-/** @todo Kakasoo */
 export declare const orchestrateAnalyze: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) => (props: IAutoBeApplicationProps) => Promise<AutoBeAssistantMessageHistory | AutoBeAnalyzeHistory>;

package/lib/orchestrate/analyze/orchestrateAnalyzeReview.d.ts

@@ -0,0 +1,5 @@
+import { AutoBeAnalyzeReviewEvent, AutoBeAnalyzeScenarioEvent, AutoBeProgressEventBase } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare const orchestrateAnalyzeReview: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, scenario: AutoBeAnalyzeScenarioEvent, otherFiles: AutoBeAnalyzeFile[], myFile: AutoBeAnalyzeFile, progress: AutoBeProgressEventBase) => Promise<AutoBeAnalyzeReviewEvent>;

package/lib/orchestrate/analyze/orchestrateAnalyzeScenario.d.ts

@@ -0,0 +1,4 @@
+import { AutoBeAnalyzeScenarioEvent, AutoBeAssistantMessageHistory } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare const orchestrateAnalyzeScenario: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) => Promise<AutoBeAnalyzeScenarioEvent | AutoBeAssistantMessageHistory>;

package/lib/orchestrate/analyze/orchestrateAnalyzeWrite.d.ts

@@ -1,14 +1,8 @@
-import { MicroAgentica } from "@agentica/core";
-import { AutoBeAnalyzeRole } from "@autobe/interface";
+import { AutoBeAnalyzeScenarioEvent, AutoBeAnalyzeWriteEvent } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-import { IFile } from "./AutoBeAnalyzeFileSystem";
-import { AutoBEAnalyzeFileMap } from "./AutoBeAnalyzePointer";
-export declare const orchestrateAnalyzeWrite: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, input: {
-    /** Total file names */
-    totalFiles: Pick<IFile, "filename" | "reason">[];
-    targetFile: string;
-    roles: AutoBeAnalyzeRole[];
-    review: string | null;
-    setDocument: (v: AutoBEAnalyzeFileMap) => void;
-}) => MicroAgentica<Model>;
+export declare const orchestrateAnalyzeWrite: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, scenario: AutoBeAnalyzeScenarioEvent, file: AutoBeAnalyzeFile.Scenario, progress: {
+    total: number;
+    completed: number;
+}) => Promise<AutoBeAnalyzeWriteEvent>;

package/lib/orchestrate/analyze/structures/IAutoBeAnalyzeReviewApplication.d.ts

@@ -0,0 +1,105 @@
+export interface IAutoBeAnalyzeReviewApplication {
+    /**
+     * Enhances planning documentation to meet all quality standards and requirements.
+     *
+     * This function receives a document and outputs an improved version directly.
+     * The output IS the enhanced document itself, NOT review comments or feedback.
+     *
+     * 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
+     */
+    review(props: IAutoBeAnalyzeReviewApplication.IProps): void;
+}
+export declare namespace IAutoBeAnalyzeReviewApplication {
+    interface IProps {
+        /**
+         * The enhancement criteria and guidelines that the agent must follow.
+         *
+         * This includes:
+         *
+         * - Minimum document length requirements
+         * - Section completeness checks
+         * - Link validation rules
+         * - Mermaid syntax validation (especially parentheses in labels)
+         * - Content specificity requirements
+         * - EARS format compliance
+         *
+         * The review criteria ensure that documentation is implementation-ready and
+         * removes all ambiguity for backend developers.
+         *
+         * Critical review points:
+         *
+         * - DO: Use double quotes for ALL labels in Mermaid diagrams
+         * - 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
+         */
+        review: string;
+        /**
+         * The document plan that was used to create the content.
+         *
+         * This helps the reviewer understand:
+         *
+         * - What sections should be present
+         * - The intended structure and organization
+         * - The target audience and purpose
+         * - Expected level of detail
+         *
+         * The enhancer uses this to ensure the improved content aligns with the
+         * original plan and covers all required topics comprehensively.
+         */
+        plan: string;
+        /**
+         * The actual markdown document content that incorporates review feedback.
+         *
+         * 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:
+         *
+         * - 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)
+         *
+         * The enhancer outputs the document itself:
+         *
+         * - 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)
+         */
+        content: string;
+    }
+}

package/lib/orchestrate/analyze/structures/IAutoBeAnalyzeScenarioApplication.d.ts

@@ -0,0 +1,78 @@
+import { AutoBeAnalyzeRole, CamelPattern } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { tags } from "typia";
+export interface IAutoBeAnalyzeScenarioApplication {
+    /**
+     * Compose project structure with roles and files.
+     *
+     * Design a list of roles and initial documents that you need to create for
+     * that requirement. Roles define team member 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 roles. Simply pass an empty array to `input.files` and `input.roles`.
+     *
+     * @param input Prefix, roles, and files
+     * @returns
+     */
+    compose(input: IAutoBeAnalyzeScenarioApplication.IProps): void;
+}
+export declare namespace IAutoBeAnalyzeScenarioApplication {
+    interface IProps {
+        /** Reason for the analysis and composition of the project structure. */
+        reason: string;
+        /**
+         * Prefix for file names and variable names. This will be used for
+         * organizing documentation files.
+         *
+         * DO: Use camelCase naming convention.
+         */
+        prefix: string & CamelPattern;
+        /** Roles to be assigned for the project */
+        roles: AutoBeAnalyzeRole[];
+        /**
+         * Language for document content. When specified by the user, this takes
+         * precedence over the locale setting for determining document language.
+         */
+        language?: string;
+        /**
+         * If the user has requested a specific number of pages, enter that number.
+         * Otherwise, provide an appropriate number of documents needed to meet the
+         * user's requirements. This number must always match the length of the
+         * files property, must be greater than 1, and must include the table of
+         * contents. For example, if the user requests 3 pages, the total should be
+         * 4, including the table of contents.
+         */
+        page: number;
+        /**
+         * # Document files to be generated
+         *
+         * File name must be English and it must contain the numbering and prefix.
+         *
+         * These files represent business documentation that may include:
+         *
+         * - Business requirements and functional specifications in natural language
+         * - User journey mapping and use case scenarios
+         * - Business rules and workflow definitions
+         * - Service overview and business model description
+         * - User roles and permission requirements (described in natural language)
+         * - Business logic and validation rules
+         * - 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.
+         * Do not create unnecessary documentation - only generate what is needed to
+         * properly define the business requirements and system specifications.
+         *
+         * # Page 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.
+         */
+        files: Array<AutoBeAnalyzeFile.Scenario> & tags.MinItems<1>;
+    }
+}

package/lib/orchestrate/analyze/structures/IAutoBeAnalyzeWriteApplication.d.ts

@@ -0,0 +1,70 @@
+export interface IAutoBeAnalyzeWriteApplication {
+    /**
+     * Creates or updates planning documentation based on the provided plan and
+     * content structure.
+     *
+     * This function is called by the AI agent to write detailed planning
+     * documents that will be used by backend developers to understand what needs
+     * to be built, why it's being built, and how it should function.
+     *
+     * @param props - The properties containing the document plan and initial
+     *   content
+     */
+    write(props: IAutoBeAnalyzeWriteApplication.IProps): void;
+}
+export declare namespace IAutoBeAnalyzeWriteApplication {
+    interface IProps {
+        /**
+         * The document planning structure that outlines what needs to be written.
+         *
+         * This includes:
+         *
+         * - Document title and purpose
+         * - Table of contents structure
+         * - Key sections to be covered
+         * - Relationships with other documents
+         * - Target audience (backend developers)
+         *
+         * The plan serves as a roadmap for the AI agent to ensure all necessary
+         * topics are covered in the documentation process.
+         *
+         * Example plan structure:
+         *
+         * - Service overview with business model
+         * - User roles and authentication requirements
+         * - Functional requirements with EARS format
+         * - Non-functional requirements
+         * - Business requirements in natural language
+         * - User scenarios and use cases
+         */
+        plan: string;
+        /**
+         * 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
+         *
+         * The content provides the raw material that the AI agent will transform
+         * into structured, developer-ready documentation following the planning
+         * guidelines.
+         *
+         * The AI agent will expand this content into comprehensive documentation
+         * that:
+         *
+         * - 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
+         * - Uses EARS format for all applicable requirements
+         * - Follows proper document linking conventions
+         * - Includes Mermaid diagrams with proper syntax (double quotes mandatory)
+         */
+        content: string;
+    }
+}

package/lib/orchestrate/interface/histories/transformInterfaceAuthorizationsHistories.d.ts

@@ -0,0 +1,4 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeRole } from "@autobe/interface";
+import { AutoBeState } from "../../../context/AutoBeState";
+export declare const transformInterfaceAuthorizationsHistories: (state: AutoBeState, role: AutoBeAnalyzeRole) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/interface/histories/transformInterfaceEndpointHistories.d.ts

@@ -1,4 +1,5 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
 import { AutoBeInterfaceGroup } from "@autobe/interface/src/histories/contents/AutoBeInterfaceGroup";
 import { AutoBeState } from "../../../context/AutoBeState";
-export declare const transformInterfaceEndpointHistories: (state: AutoBeState, group: AutoBeInterfaceGroup) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;
+export declare const transformInterfaceEndpointHistories: (state: AutoBeState, group: AutoBeInterfaceGroup, authorizations: AutoBeOpenApi.IOperation[]) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/interface/histories/transformInterfaceOperationsReviewHistories.d.ts

@@ -0,0 +1,5 @@
+import { IMicroAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+export declare function transformInterfaceOperationsReviewHistories<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operations: AutoBeOpenApi.IOperation[]): Array<IMicroAgenticaHistoryJson>;

package/lib/orchestrate/interface/histories/transformInterfaceSchemasReviewHistories.d.ts

@@ -0,0 +1,4 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeState } from "../../../context/AutoBeState";
+export declare const transformInterfaceSchemasReviewHistories: (state: AutoBeState, operations: AutoBeOpenApi.IOperation[], schemaDescriptive: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema>>) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

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

@@ -0,0 +1,4 @@
+import { AutoBeInterfaceAuthorization } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare function orchestrateInterfaceAuthorizations<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>): Promise<AutoBeInterfaceAuthorization[]>;

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

@@ -2,4 +2,4 @@ import { AutoBeOpenApi } from "@autobe/interface";
 import { AutoBeInterfaceGroup } from "@autobe/interface/src/histories/contents/AutoBeInterfaceGroup";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestrateInterfaceEndpoints<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, groups: AutoBeInterfaceGroup[], content?: string): Promise<AutoBeOpenApi.IEndpoint[]>;
+export declare function orchestrateInterfaceEndpoints<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, groups: AutoBeInterfaceGroup[], authorizations: AutoBeOpenApi.IOperation[], content?: string): Promise<AutoBeOpenApi.IEndpoint[]>;

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

@@ -1,4 +1,4 @@
-import { AutoBeAssistantMessageHistory, AutoBeInterfaceGroupsEvent } from "@autobe/interface";
+import { AutoBeInterfaceGroupsEvent } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestrateInterfaceGroups<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, content?: string): Promise<AutoBeAssistantMessageHistory | AutoBeInterfaceGroupsEvent>;
+export declare function orchestrateInterfaceGroups<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, message?: string): Promise<AutoBeInterfaceGroupsEvent>;

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

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

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

@@ -0,0 +1,7 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare 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>>;

package/lib/orchestrate/interface/structures/IAutoBeInterfaceAuthorizationsApplication.d.ts

@@ -0,0 +1,47 @@
+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 declare namespace IAutoBeInterfaceAuthorizationsApplication {
+    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/lib/orchestrate/interface/structures/IAutoBeInterfaceComplementApplication.d.ts

@@ -17,6 +17,44 @@ export interface IAutoBeInterfaceComplementApplication {
 }
 export declare namespace IAutoBeInterfaceComplementApplication {
     interface IProps {
+        /**
+         * TypeScript draft code for complement schema definitions.
+         *
+         * This property contains TypeScript interface definitions for missing schema
+         * types that were referenced but not defined in the initial schema generation.
+         * Similar to the main schema draft, this serves as a preliminary TypeScript
+         * representation before converting to JSON Schema format.
+         *
+         * The draft helps ensure that complementary schemas maintain consistency with
+         * the existing type system and follow the same conventions as the primary schemas.
+         *
+         * This draft typically includes:
+         * - Missing entity interfaces referenced via $ref
+         * - Nested object types used within other schemas
+         * - Shared utility types or enumerations
+         * - Any transitively referenced types
+         *
+         * The final schemas in the `schemas` property should be validated against and
+         * derived from this TypeScript draft to ensure type safety and consistency
+         * across the entire API specification.
+         *
+         * Example complement draft:
+         * ```typescript
+         * interface IUserProfile {
+         *   id: string;
+         *   userId: string;
+         *   displayName: string;
+         *   avatarUrl?: string;
+         * }
+         *
+         * interface IAddress {
+         *   street: string;
+         *   city: string;
+         *   postalCode: string;
+         * }
+         * ```
+         */
+        draft: string;
         /**
          * A collection of missing schema definitions that need to be added to the
          * OpenAPI document's `components.schemas` section.