@autobe/agent 0.28.0 → 0.29.0

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

@@ -1,90 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeOpenApi } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
-import { v7 } from "uuid";
-
-import { AutoBeState } from "../../../context/AutoBeState";
-import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHistories";
-
-export const transformInterfaceSchemaReviewHistories = (props: {
-  state: AutoBeState;
-  systemPrompt: string;
-  instruction: string;
-  operations: AutoBeOpenApi.IOperation[];
-  everySchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
-  reviewSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
-}): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => {
-  return [
-    {
-      type: "systemMessage",
-      id: v7(),
-      created_at: new Date().toISOString(),
-      text: props.systemPrompt,
-    },
-    ...transformInterfaceAssetHistories(props.state),
-    {
-      type: "assistantMessage",
-      id: v7(),
-      created_at: new Date().toISOString(),
-      text: StringUtil.trim`
-        ## API Design Instructions
-
-        The following API-specific instructions were extracted from
-        the user's requirements. These focus on API interface design aspects
-        relevant to the review task.
-
-        Follow these instructions when reviewing and fixing schemas.
-        Carefully distinguish between:
-        - Suggestions or recommendations (consider these as guidance)
-        - Direct specifications or explicit commands (these must be followed exactly)
-
-        When instructions contain direct specifications or explicit design decisions,
-        follow them precisely even if you believe you have better alternatives.
-
-        ${props.instruction}
-
-        ## Schemas (Complete Set for Reference)
-
-        Here is the COMPLETE set of all schemas in the system for
-        reference context:
-
-        \`\`\`json
-        ${JSON.stringify(props.everySchemas)}
-        \`\`\`
-      `,
-    },
-    {
-      id: v7(),
-      type: "assistantMessage",
-      created_at: new Date().toISOString(),
-      text: StringUtil.trim`
-        ## Schemas Needing Review
-
-        From the complete schema set above, here are the SPECIFIC schemas that need review:
-
-        \`\`\`json
-        ${JSON.stringify(props.reviewSchemas)}
-        \`\`\`
-
-        IMPORTANT: Only these ${Object.keys(props.reviewSchemas).length} schemas
-        need review and potential modification. The other schemas in
-        the full set are provided for reference only.
-
-        ## Operations (Filtered for Target Schemas)
-
-        Here are the API operations that directly use the schemas under review.
-        These operations reference at least one of the target schemas via
-        requestBody.typeName or responseBody.typeName.
-
-        This FILTERED list helps you understand the exact usage context for
-        the schemas you're reviewing:
-
-        \`\`\`json
-        ${JSON.stringify(props.operations)}
-        \`\`\`
-      `,
-    },
-  ];
-};

package/src/orchestrate/interface/orchestrateInterfaceEndpoints.ts

@@ -1,152 +0,0 @@
-import { IAgenticaController } from "@agentica/core";
-import {
-  AutoBeInterfaceEndpointEvent,
-  AutoBeOpenApi,
-  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";
-import { v7 } from "uuid";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformInterfaceEndpointHistories } from "./histories/transformInterfaceEndpointHistories";
-import { orchestrateInterfaceEndpointsReview } from "./orchestrateInterfaceEndpointsReview";
-import { IAutoBeInterfaceEndpointApplication } from "./structures/IAutoBeInterfaceEndpointApplication";
-
-export async function orchestrateInterfaceEndpoints<
-  Model extends ILlmSchema.Model,
->(
-  ctx: AutoBeContext<Model>,
-  props: {
-    groups: AutoBeInterfaceGroup[];
-    authorizations: AutoBeOpenApi.IOperation[];
-    instruction: string;
-    message?: string;
-  },
-): Promise<AutoBeOpenApi.IEndpoint[]> {
-  const progress: AutoBeProgressEventBase = {
-    total: props.groups.length,
-    completed: 0,
-  };
-  const endpoints: AutoBeOpenApi.IEndpoint[] = (
-    await executeCachedBatch(
-      props.groups.map(
-        (group) => (promptCacheKey) =>
-          process(ctx, {
-            group,
-            authorizations: props.authorizations,
-            instruction: props.instruction,
-            message: props.message ?? "Make endpoints for the given assets.",
-            progress,
-            promptCacheKey,
-          }),
-      ),
-    )
-  ).flat();
-  const deduplicated: AutoBeOpenApi.IEndpoint[] = new HashSet(
-    endpoints,
-    AutoBeOpenApiEndpointComparator.hashCode,
-    AutoBeOpenApiEndpointComparator.equals,
-  ).toJSON();
-  return await orchestrateInterfaceEndpointsReview(ctx, deduplicated);
-}
-
-async function process<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-  props: {
-    group: AutoBeInterfaceGroup;
-    message: string;
-    progress: AutoBeProgressEventBase;
-    authorizations: AutoBeOpenApi.IOperation[];
-    promptCacheKey: string;
-    instruction: string;
-  },
-): Promise<AutoBeOpenApi.IEndpoint[]> {
-  const start: Date = new Date();
-  const pointer: IPointer<AutoBeOpenApi.IEndpoint[] | null> = {
-    value: null,
-  };
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "interfaceEndpoint",
-    histories: transformInterfaceEndpointHistories({
-      state: ctx.state(),
-      group: props.group,
-      authorizations: props.authorizations,
-      instruction: props.instruction,
-    }),
-    controller: createController({
-      model: ctx.model,
-      build: (endpoints) => {
-        pointer.value ??= endpoints;
-        pointer.value.push(...endpoints);
-      },
-    }),
-    enforceFunctionCall: true,
-    promptCacheKey: props.promptCacheKey,
-    message: props.message,
-  });
-  if (pointer.value === null) throw new Error("Failed to generate endpoints."); // unreachable
-
-  const event: AutoBeInterfaceEndpointEvent = {
-    type: "interfaceEndpoint",
-    id: v7(),
-    endpoints: new HashSet(
-      pointer.value,
-      AutoBeOpenApiEndpointComparator.hashCode,
-      AutoBeOpenApiEndpointComparator.equals,
-    ).toJSON(),
-    metric,
-    tokenUsage,
-    created_at: start.toISOString(),
-    step: ctx.state().analyze?.step ?? 0,
-    completed: ++props.progress.completed,
-    total: props.progress.total,
-  };
-  ctx.dispatch(event);
-  return pointer.value;
-}
-
-function createController<Model extends ILlmSchema.Model>(props: {
-  model: Model;
-  build: (endpoints: AutoBeOpenApi.IEndpoint[]) => void;
-}): 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: "interface",
-    application,
-    execute: {
-      makeEndpoints: (next) => {
-        props.build(next.endpoints);
-      },
-    } satisfies IAutoBeInterfaceEndpointApplication,
-  };
-}
-
-const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeInterfaceEndpointApplication,
-    "chatgpt"
-  >(),
-  claude: typia.llm.application<
-    IAutoBeInterfaceEndpointApplication,
-    "claude"
-  >(),
-  gemini: typia.llm.application<
-    IAutoBeInterfaceEndpointApplication,
-    "gemini"
-  >(),
-};

package/src/orchestrate/interface/orchestrateInterfaceEndpointsReview.ts

@@ -1,98 +0,0 @@
-import { IAgenticaController } from "@agentica/core";
-import { AutoBeOpenApi } from "@autobe/interface";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
-import { IPointer } from "tstl";
-import typia from "typia";
-import { v7 } from "uuid";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { transformInterfaceEndpointsReviewHistories } from "./histories/transformInterfaceEndpointsReviewHistories";
-import { IAutoBeInterfaceEndpointsReviewApplication } from "./structures/IAutoBeInterfaceEndpointsReviewApplication";
-
-export async function orchestrateInterfaceEndpointsReview<
-  Model extends ILlmSchema.Model,
->(
-  ctx: AutoBeContext<Model>,
-  endpoints: AutoBeOpenApi.IEndpoint[],
-  message: string = `Review the generated endpoints`,
-): Promise<AutoBeOpenApi.IEndpoint[]> {
-  const pointer: IPointer<IAutoBeInterfaceEndpointsReviewApplication.IProps | null> =
-    {
-      value: null,
-    };
-
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "interfaceEndpointReview",
-    histories: transformInterfaceEndpointsReviewHistories(
-      ctx.state(),
-      endpoints,
-    ),
-    controller: createController({
-      model: ctx.model,
-      build: (props) => {
-        pointer.value = props;
-      },
-    }),
-    enforceFunctionCall: true,
-    message,
-  });
-
-  if (pointer.value === null) {
-    return endpoints;
-  }
-
-  const response = pointer.value?.endpoints ?? [];
-  ctx.dispatch({
-    id: v7(),
-    type: "interfaceEndpointReview",
-    endpoints,
-    content: response,
-    created_at: new Date().toISOString(),
-    review: pointer.value?.review,
-    step: ctx.state().analyze?.step ?? 0,
-    metric,
-    tokenUsage,
-  });
-  return response;
-}
-
-function createController<Model extends ILlmSchema.Model>(props: {
-  model: Model;
-  build: (props: IAutoBeInterfaceEndpointsReviewApplication.IProps) => void;
-}): 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: "interface",
-    application,
-    execute: {
-      reviewEndpoints: (next) => {
-        props.build(next);
-      },
-    } satisfies IAutoBeInterfaceEndpointsReviewApplication,
-  };
-}
-
-const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeInterfaceEndpointsReviewApplication,
-    "chatgpt"
-  >(),
-  claude: typia.llm.application<
-    IAutoBeInterfaceEndpointsReviewApplication,
-    "claude"
-  >(),
-  gemini: typia.llm.application<
-    IAutoBeInterfaceEndpointsReviewApplication,
-    "gemini"
-  >(),
-};

package/src/orchestrate/interface/orchestrateInterfaceGroups.ts

@@ -1,91 +0,0 @@
-import { IAgenticaController } from "@agentica/core";
-import { AutoBeInterfaceGroupEvent } from "@autobe/interface";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
-import { IPointer } from "tstl";
-import typia from "typia";
-import { v7 } from "uuid";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { transformInterfaceGroupHistories } from "./histories/transformInterfaceGroupHistories";
-import { IAutoBeInterfaceGroupApplication } from "./structures/IAutoBeInterfaceGroupApplication";
-
-export async function orchestrateInterfaceGroups<
-  Model extends ILlmSchema.Model,
->(
-  ctx: AutoBeContext<Model>,
-  props: {
-    instruction: string;
-    message?: string;
-  },
-): Promise<AutoBeInterfaceGroupEvent> {
-  const start: Date = new Date();
-  const pointer: IPointer<IAutoBeInterfaceGroupApplication.IProps | null> = {
-    value: null,
-  };
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "interfaceGroup",
-    histories: transformInterfaceGroupHistories({
-      state: ctx.state(),
-      instruction: props.instruction,
-    }),
-    controller: createController({
-      model: ctx.model,
-      build: (next) => {
-        pointer.value = next;
-      },
-    }),
-    enforceFunctionCall: true,
-    message: props.message ?? "Design API operations for the given assets.",
-  });
-  if (pointer.value === null) throw new Error("Failed to generate groups."); // unreachable
-  return {
-    type: "interfaceGroup",
-    id: v7(),
-    created_at: start.toISOString(),
-    groups: pointer.value.groups,
-    metric,
-    tokenUsage,
-    step: ctx.state().analyze?.step ?? 0,
-  } satisfies AutoBeInterfaceGroupEvent;
-}
-
-function createController<Model extends ILlmSchema.Model>(props: {
-  model: Model;
-  build: (next: IAutoBeInterfaceGroupApplication.IProps) => void;
-}): 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: "interface",
-    application,
-    execute: {
-      makeGroups: (next) => {
-        props.build(next);
-      },
-    } satisfies IAutoBeInterfaceGroupApplication,
-  };
-}
-
-const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeInterfaceGroupApplication,
-    "chatgpt"
-  >(),
-  claude: typia.llm.application<
-    IAutoBeInterfaceGroupApplication,
-    "claude"
-  >(),
-  gemini: typia.llm.application<
-    IAutoBeInterfaceGroupApplication,
-    "gemini"
-  >(),
-};

package/src/orchestrate/interface/orchestrateInterfaceOperationsReview.ts

@@ -1,157 +0,0 @@
-import { IAgenticaController } from "@agentica/core";
-import {
-  AutoBeInterfaceOperationReviewEvent,
-  AutoBeOpenApi,
-  AutoBePrisma,
-  AutoBeProgressEventBase,
-} from "@autobe/interface";
-import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
-import { IPointer } from "tstl";
-import typia from "typia";
-import { v7 } from "uuid";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { transformInterfaceOperationsReviewHistories } from "./histories/transformInterfaceOperationsReviewHistories";
-import { IAutoBeInterfaceOperationsReviewApplication } from "./structures/IAutoBeInterfaceOperationsReviewApplication";
-import { OperationValidator } from "./utils/OperationValidator";
-
-export async function orchestrateInterfaceOperationsReview<
-  Model extends ILlmSchema.Model,
->(
-  ctx: AutoBeContext<Model>,
-  operations: AutoBeOpenApi.IOperation[],
-  progress: AutoBeProgressEventBase,
-): Promise<AutoBeOpenApi.IOperation[]> {
-  try {
-    const files: AutoBePrisma.IFile[] = ctx.state().prisma?.result.data.files!;
-    const pointer: IPointer<IAutoBeInterfaceOperationsReviewApplication.IProps | null> =
-      {
-        value: null,
-      };
-    const { metric, tokenUsage } = await ctx.conversate({
-      source: "interfaceOperationReview",
-      histories: transformInterfaceOperationsReviewHistories(ctx, operations),
-      controller: createReviewController({
-        model: ctx.model,
-        prismaSchemas: files,
-        build: (next: IAutoBeInterfaceOperationsReviewApplication.IProps) => {
-          pointer.value = next;
-        },
-      }),
-      enforceFunctionCall: false,
-      message: "Review the operations",
-    });
-    if (pointer.value === null) {
-      ++progress.completed;
-      return [];
-    }
-
-    const content: AutoBeOpenApi.IOperation[] = pointer.value.content.map(
-      (op) => ({
-        ...op,
-        authorizationType: null,
-      }),
-    );
-
-    ctx.dispatch({
-      type: "interfaceOperationReview",
-      id: v7(),
-      operations: content,
-      review: pointer.value.think.review,
-      plan: pointer.value.think.plan,
-      content,
-      metric,
-      tokenUsage,
-      created_at: new Date().toISOString(),
-      step: ctx.state().analyze?.step ?? 0,
-      total: progress.total,
-      completed: ++progress.completed,
-    } satisfies AutoBeInterfaceOperationReviewEvent);
-    return content;
-  } catch {
-    ++progress.completed;
-    return [];
-  }
-}
-
-function createReviewController<Model extends ILlmSchema.Model>(props: {
-  model: Model;
-  prismaSchemas: AutoBePrisma.IFile[];
-  build: (reviews: IAutoBeInterfaceOperationsReviewApplication.IProps) => void;
-}): IAgenticaController.IClass<Model> {
-  const validate = (
-    next: unknown,
-  ): IValidation<IAutoBeInterfaceOperationsReviewApplication.IProps> => {
-    const result: IValidation<IAutoBeInterfaceOperationsReviewApplication.IProps> =
-      typia.validate<IAutoBeInterfaceOperationsReviewApplication.IProps>(next);
-    if (result.success === false) return result;
-
-    const errors: IValidation.IError[] = [];
-    OperationValidator.validate({
-      path: "$input.content",
-      operations: result.data.content,
-      errors,
-    });
-    if (errors.length !== 0)
-      return {
-        success: false,
-        errors,
-        data: next,
-      };
-    return result;
-  };
-  const application: ILlmApplication<Model> = collection[
-    props.model === "chatgpt"
-      ? "chatgpt"
-      : props.model === "gemini"
-        ? "gemini"
-        : "claude"
-  ](
-    validate,
-  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
-
-  return {
-    protocol: "class",
-    name: "review",
-    application,
-    execute: {
-      reviewOperations: (next) => {
-        props.build(next);
-      },
-    } satisfies IAutoBeInterfaceOperationsReviewApplication,
-  };
-}
-
-const collection = {
-  chatgpt: (validate: Validator) =>
-    typia.llm.application<
-      IAutoBeInterfaceOperationsReviewApplication,
-      "chatgpt"
-    >({
-      validate: {
-        reviewOperations: validate,
-      },
-    }),
-  claude: (validate: Validator) =>
-    typia.llm.application<
-      IAutoBeInterfaceOperationsReviewApplication,
-      "claude"
-    >({
-      validate: {
-        reviewOperations: validate,
-      },
-    }),
-  gemini: (validate: Validator) =>
-    typia.llm.application<
-      IAutoBeInterfaceOperationsReviewApplication,
-      "gemini"
-    >({
-      validate: {
-        reviewOperations: validate,
-      },
-    }),
-};
-
-type Validator = (
-  input: unknown,
-) => IValidation<IAutoBeInterfaceOperationsReviewApplication.IProps>;

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

@@ -1,65 +0,0 @@
-import { AutoBeOpenApi } from "@autobe/interface";
-
-/**
- * Interface for reviewing and refining API endpoints through holistic analysis.
- * 
- * This application performs comprehensive review of all endpoints generated
- * through divide-and-conquer strategy, ensuring consistency, eliminating
- * redundancy, and preventing over-engineering across the entire API surface.
- */
-export interface IAutoBeInterfaceEndpointsReviewApplication {
-  /**
-   * Reviews and refines the complete collection of API endpoints.
-   * 
-   * This method consolidates all endpoints generated independently by different
-   * groups and performs holistic review to:
-   * - Ensure naming consistency across all endpoints
-   * - Remove duplicate or overlapping endpoints
-   * - Eliminate over-engineered solutions
-   * - Standardize path structures and HTTP methods
-   * - Verify REST API design principles
-   * 
-   * The review process examines the entire API as a cohesive system rather
-   * than individual endpoints, ensuring the final API is intuitive, maintainable,
-   * and follows best practices.
-   * 
-   * @param next - The review results and refined endpoint collection
-   */
-  reviewEndpoints(
-    next: IAutoBeInterfaceEndpointsReviewApplication.IProps,
-  ): void;
-}
-
-export namespace IAutoBeInterfaceEndpointsReviewApplication {
-  export interface IProps {
-    /**
-     * Comprehensive review analysis of all collected endpoints.
-     * 
-     * Contains detailed findings from the holistic review including:
-     * - Identified inconsistencies in naming conventions
-     * - Duplicate endpoints that serve the same purpose
-     * - Over-engineered solutions that add unnecessary complexity
-     * - Violations of REST API design principles
-     * - Recommendations for improvement and standardization
-     * 
-     * The review provides actionable feedback for creating a clean,
-     * consistent, and maintainable API structure.
-     */
-    review: string;
-
-    /**
-     * Refined collection of API endpoints after review and cleanup.
-     * 
-     * The final optimized set of endpoints after:
-     * - Removing duplicates and redundant endpoints
-     * - Standardizing naming conventions across all paths
-     * - Simplifying over-engineered solutions
-     * - Ensuring consistent REST patterns
-     * - Aligning HTTP methods with their semantic meanings
-     * 
-     * This collection represents the production-ready API structure
-     * that balances functionality with simplicity and maintainability.
-     */
-    endpoints: AutoBeOpenApi.IEndpoint[];
-  }
-}