@autobe/agent 0.28.1 → 0.29.1

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

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

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

@@ -1,80 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeOpenApi } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
-import { v7 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../../context/AutoBeState";
-import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHistories";
-
-export const transformInterfaceSchemaHistories = (props: {
-  state: AutoBeState;
-  operations: AutoBeOpenApi.IOperation[];
-  typeNames: string[];
-  instruction: string;
-}): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => {
-  const schemas: Set<string> = new Set();
-  for (const op of props.operations) {
-    if (op.requestBody) schemas.add(op.requestBody.typeName);
-    if (op.responseBody) schemas.add(op.responseBody.typeName);
-  }
-  return [
-    {
-      type: "systemMessage",
-      id: v7(),
-      created_at: new Date().toISOString(),
-      text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA,
-    },
-    ...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
-      such as endpoint patterns, request/response formats, DTO schemas,
-      and operation specifications.
-
-      Follow these instructions when creating JSON schema components.
-      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}
-
-      ## Operations (Filtered for Target Schemas)
-
-      Here is the list of API operations that directly use the schemas
-      you need to generate (via requestBody.typeName or responseBody.typeName).
-
-      These are the ONLY operations relevant to your current task - other
-      operations have been filtered out to reduce noise and improve focus:
-
-      \`\`\`json
-      ${JSON.stringify(props.operations)}
-      \`\`\`
-
-      ## Schemas
-
-      Here is the list of request/response bodies' type names from
-      OpenAPI operations.
-
-      Reference them when creating DTO schema components, especially
-      considering the DTO relationships.
-
-      ${Array.from(schemas)
-        .map((k) => `- \`${k}\``)
-        .join("\n")}
-
-    `,
-    },
-  ];
-};

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

@@ -1,55 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { StringUtil } from "@autobe/utils";
-import { v7 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
-
-export const transformInterfaceSchemaRenameHistories = (props: {
-  tableNames: string[];
-  typeNames: string[];
-}): Array<
-  IAgenticaHistoryJson.ISystemMessage | IAgenticaHistoryJson.IAssistantMessage
-> => {
-  return [
-    {
-      type: "systemMessage",
-      id: v7(),
-      created_at: new Date().toISOString(),
-      text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA_RENAME,
-    },
-    {
-      type: "assistantMessage",
-      id: v7(),
-      created_at: new Date().toISOString(),
-      text: StringUtil.trim`
-        ## Prisma Table Names
-
-        Here is the complete list of table names from the Prisma database schema.
-        Use these as the source of truth for determining correct DTO type names.
-
-        Each table name should be converted to a DTO type name by:
-        1. Converting from snake_case to PascalCase
-        2. Preserving ALL words from the table name
-        3. Adding "I" prefix for interface types
-
-        **Table Names:**
-        ${props.tableNames.map((name) => `- \`${name}\``).join("\n")}
-
-        ## Current DTO Type Names
-
-        Here is the list of existing DTO type names currently in the OpenAPI specification.
-        Analyze these to identify which ones violate the naming rules by omitting
-        intermediate words or service prefixes from their corresponding table names.
-
-        **Current Type Names:**
-        ${props.typeNames.map((name) => `- \`${name}\``).join("\n")}
-
-        ## Your Task
-
-        Compare the table names with the current type names to identify violations.
-        For each type name that incorrectly omits words from its table name,
-        provide a refactoring entry with the correct name that preserves all components.
-      `,
-    },
-  ];
-};

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"
-  >(),
-};