@autobe/agent 0.30.0-dev.20260315 → 0.30.0

package/src/orchestrate/interface/orchestrateInterfaceAuthorization.ts

@@ -1,208 +1,208 @@
-import { IAgenticaController } from "@agentica/core";
-import {
-  AutoBeAnalyze,
-  AutoBeEventSource,
-  AutoBeInterfaceAuthorization,
-  AutoBeInterfaceAuthorizationEvent,
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-} from "@autobe/interface";
-import { NamingConvention } from "@typia/utils";
-import { IPointer } from "tstl";
-import typia, { ILlmApplication, IValidation } from "typia";
-import { v7 } from "uuid";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
-import { transformInterfaceAuthorizationHistory } from "./histories/transformInterfaceAuthorizationHistory";
-import { AutoBeInterfaceAuthorizationProgrammer } from "./programmers/AutoBeInterfaceAuthorizationProgrammer";
-import { IAutoBeInterfaceAuthorizationApplication } from "./structures/IAutoBeInterfaceAuthorizationApplication";
-import { AutoBeJsonSchemaFactory } from "./utils/AutoBeJsonSchemaFactory";
-
-export async function orchestrateInterfaceAuthorization(
-  ctx: AutoBeContext,
-  props: {
-    instruction: string;
-  },
-): Promise<AutoBeInterfaceAuthorization[]> {
-  const actors: AutoBeAnalyze.IActor[] = ctx.state().analyze?.actors ?? [];
-  const progress: AutoBeProgressEventBase = {
-    total: actors.length,
-    completed: 0,
-  };
-  return await executeCachedBatch(
-    ctx,
-    actors.map((a) => async (promptCacheKey) => {
-      const event: AutoBeInterfaceAuthorizationEvent = await process(ctx, {
-        actor: a,
-        progress,
-        promptCacheKey,
-        instruction: props.instruction,
-      });
-      ctx.dispatch(event);
-      return {
-        name: a.name,
-        operations: event.operations,
-      };
-    }),
-  );
-}
-
-async function process(
-  ctx: AutoBeContext,
-  props: {
-    instruction: string;
-    actor: AutoBeAnalyze.IActor;
-    progress: AutoBeProgressEventBase;
-    promptCacheKey: string;
-  },
-): Promise<AutoBeInterfaceAuthorizationEvent> {
-  const prefix: string = NamingConvention.camel(ctx.state().analyze!.prefix);
-  const preliminary: AutoBePreliminaryController<
-    | "analysisSections"
-    | "previousAnalysisSections"
-    | "databaseSchemas"
-    | "previousDatabaseSchemas"
-  > = new AutoBePreliminaryController({
-    application:
-      typia.json.application<IAutoBeInterfaceAuthorizationApplication>(),
-    source: SOURCE,
-    kinds: [
-      "analysisSections",
-      "previousAnalysisSections",
-      "databaseSchemas",
-      "previousDatabaseSchemas",
-    ],
-    state: ctx.state(),
-  });
-  return await preliminary.orchestrate(ctx, async (out) => {
-    const pointer: IPointer<IAutoBeInterfaceAuthorizationApplication.IComplete | null> =
-      {
-        value: null,
-      };
-    const result: AutoBeContext.IResult = await ctx.conversate({
-      source: SOURCE,
-      controller: createController({
-        actor: props.actor,
-        build: (next) => {
-          pointer.value = next;
-        },
-        preliminary,
-        prefix,
-      }),
-      enforceFunctionCall: true,
-      promptCacheKey: props.promptCacheKey,
-      ...transformInterfaceAuthorizationHistory({
-        state: ctx.state(),
-        prefix,
-        instruction: props.instruction,
-        actor: props.actor,
-        preliminary,
-      }),
-    });
-    if (pointer.value === null) return out(result)(null);
-
-    const operations: AutoBeOpenApi.IOperation[] =
-      AutoBeInterfaceAuthorizationProgrammer.fixOperations({
-        operations: pointer.value?.operations ?? [],
-        prefix,
-      });
-    return out(result)({
-      type: SOURCE,
-      id: v7(),
-      analysis: pointer.value.analysis,
-      rationale: pointer.value.rationale,
-      operations,
-      acquisition: preliminary.getAcquisition(),
-      metric: result.metric,
-      tokenUsage: result.tokenUsage,
-      created_at: new Date().toISOString(),
-      step: ctx.state().analyze?.step ?? 0,
-      total: props.progress.total,
-      completed: ++props.progress.completed,
-    } satisfies AutoBeInterfaceAuthorizationEvent);
-  });
-}
-
-function createController(props: {
-  prefix: string | null;
-  actor: AutoBeAnalyze.IActor;
-  preliminary: AutoBePreliminaryController<
-    | "analysisSections"
-    | "previousAnalysisSections"
-    | "databaseSchemas"
-    | "previousDatabaseSchemas"
-  >;
-  build: (next: IAutoBeInterfaceAuthorizationApplication.IComplete) => void;
-}): IAgenticaController.IClass {
-  const validate = (
-    next: unknown,
-  ): IValidation<IAutoBeInterfaceAuthorizationApplication.IProps> => {
-    const result: IValidation<IAutoBeInterfaceAuthorizationApplication.IProps> =
-      typia.validate<IAutoBeInterfaceAuthorizationApplication.IProps>(next);
-    if (result.success === false) return result;
-    else if (result.data.request.type !== "complete")
-      return props.preliminary.validate({
-        thinking: result.data.thinking,
-        request: result.data.request,
-      });
-
-    const errors: IValidation.IError[] = [];
-    AutoBeInterfaceAuthorizationProgrammer.validateAuthorizationTypes({
-      errors,
-      actor: props.actor,
-      operations: result.data.request.operations,
-      accessor: "$input.request.operations",
-    });
-    result.data.request.operations.forEach((operation, index) =>
-      AutoBeInterfaceAuthorizationProgrammer.validateOperation({
-        errors,
-        prefix: props.prefix,
-        actor: props.actor,
-        operation,
-        accessor: `$input.request.operations[${index}]`,
-      }),
-    );
-    if (errors.length !== 0) {
-      return {
-        success: false,
-        errors,
-        data: next,
-      };
-    }
-    return result;
-  };
-
-  const application: ILlmApplication = props.preliminary.fixApplication(
-    typia.llm.application<IAutoBeInterfaceAuthorizationApplication>({
-      validate: {
-        process: validate,
-      },
-    }),
-  );
-  return {
-    protocol: "class",
-    name: SOURCE,
-    application,
-    execute: {
-      process: (next) => {
-        if (next.request.type === "complete") {
-          for (const o of next.request.operations)
-            for (const p of o.parameters)
-              AutoBeJsonSchemaFactory.fixSchema(p.schema);
-          next.request.operations = next.request.operations.filter(
-            (operation) =>
-              AutoBeInterfaceAuthorizationProgrammer.filter({
-                actor: props.actor.kind,
-                operation,
-              }),
-          );
-          props.build(next.request);
-        }
-      },
-    } satisfies IAutoBeInterfaceAuthorizationApplication,
-  };
-}
-
-const SOURCE = "interfaceAuthorization" satisfies AutoBeEventSource;
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeAnalyze,
+  AutoBeEventSource,
+  AutoBeInterfaceAuthorization,
+  AutoBeInterfaceAuthorizationEvent,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+} from "@autobe/interface";
+import { NamingConvention } from "@typia/utils";
+import { IPointer } from "tstl";
+import typia, { ILlmApplication, IValidation } from "typia";
+import { v7 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformInterfaceAuthorizationHistory } from "./histories/transformInterfaceAuthorizationHistory";
+import { AutoBeInterfaceAuthorizationProgrammer } from "./programmers/AutoBeInterfaceAuthorizationProgrammer";
+import { IAutoBeInterfaceAuthorizationApplication } from "./structures/IAutoBeInterfaceAuthorizationApplication";
+import { AutoBeJsonSchemaFactory } from "./utils/AutoBeJsonSchemaFactory";
+
+export async function orchestrateInterfaceAuthorization(
+  ctx: AutoBeContext,
+  props: {
+    instruction: string;
+  },
+): Promise<AutoBeInterfaceAuthorization[]> {
+  const actors: AutoBeAnalyze.IActor[] = ctx.state().analyze?.actors ?? [];
+  const progress: AutoBeProgressEventBase = {
+    total: actors.length,
+    completed: 0,
+  };
+  return await executeCachedBatch(
+    ctx,
+    actors.map((a) => async (promptCacheKey) => {
+      const event: AutoBeInterfaceAuthorizationEvent = await process(ctx, {
+        actor: a,
+        progress,
+        promptCacheKey,
+        instruction: props.instruction,
+      });
+      ctx.dispatch(event);
+      return {
+        name: a.name,
+        operations: event.operations,
+      };
+    }),
+  );
+}
+
+async function process(
+  ctx: AutoBeContext,
+  props: {
+    instruction: string;
+    actor: AutoBeAnalyze.IActor;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+  },
+): Promise<AutoBeInterfaceAuthorizationEvent> {
+  const prefix: string = NamingConvention.camel(ctx.state().analyze!.prefix);
+  const preliminary: AutoBePreliminaryController<
+    | "analysisSections"
+    | "previousAnalysisSections"
+    | "databaseSchemas"
+    | "previousDatabaseSchemas"
+  > = new AutoBePreliminaryController({
+    application:
+      typia.json.application<IAutoBeInterfaceAuthorizationApplication>(),
+    source: SOURCE,
+    kinds: [
+      "analysisSections",
+      "previousAnalysisSections",
+      "databaseSchemas",
+      "previousDatabaseSchemas",
+    ],
+    state: ctx.state(),
+  });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeInterfaceAuthorizationApplication.IComplete | null> =
+      {
+        value: null,
+      };
+    const result: AutoBeContext.IResult = await ctx.conversate({
+      source: SOURCE,
+      controller: createController({
+        actor: props.actor,
+        build: (next) => {
+          pointer.value = next;
+        },
+        preliminary,
+        prefix,
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformInterfaceAuthorizationHistory({
+        state: ctx.state(),
+        prefix,
+        instruction: props.instruction,
+        actor: props.actor,
+        preliminary,
+      }),
+    });
+    if (pointer.value === null) return out(result)(null);
+
+    const operations: AutoBeOpenApi.IOperation[] =
+      AutoBeInterfaceAuthorizationProgrammer.fixOperations({
+        operations: pointer.value?.operations ?? [],
+        prefix,
+      });
+    return out(result)({
+      type: SOURCE,
+      id: v7(),
+      analysis: pointer.value.analysis,
+      rationale: pointer.value.rationale,
+      operations,
+      acquisition: preliminary.getAcquisition(),
+      metric: result.metric,
+      tokenUsage: result.tokenUsage,
+      created_at: new Date().toISOString(),
+      step: ctx.state().analyze?.step ?? 0,
+      total: props.progress.total,
+      completed: ++props.progress.completed,
+    } satisfies AutoBeInterfaceAuthorizationEvent);
+  });
+}
+
+function createController(props: {
+  prefix: string | null;
+  actor: AutoBeAnalyze.IActor;
+  preliminary: AutoBePreliminaryController<
+    | "analysisSections"
+    | "previousAnalysisSections"
+    | "databaseSchemas"
+    | "previousDatabaseSchemas"
+  >;
+  build: (next: IAutoBeInterfaceAuthorizationApplication.IComplete) => void;
+}): IAgenticaController.IClass {
+  const validate = (
+    next: unknown,
+  ): IValidation<IAutoBeInterfaceAuthorizationApplication.IProps> => {
+    const result: IValidation<IAutoBeInterfaceAuthorizationApplication.IProps> =
+      typia.validate<IAutoBeInterfaceAuthorizationApplication.IProps>(next);
+    if (result.success === false) return result;
+    else if (result.data.request.type !== "complete")
+      return props.preliminary.validate({
+        thinking: result.data.thinking,
+        request: result.data.request,
+      });
+
+    const errors: IValidation.IError[] = [];
+    AutoBeInterfaceAuthorizationProgrammer.validateAuthorizationTypes({
+      errors,
+      actor: props.actor,
+      operations: result.data.request.operations,
+      accessor: "$input.request.operations",
+    });
+    result.data.request.operations.forEach((operation, index) =>
+      AutoBeInterfaceAuthorizationProgrammer.validateOperation({
+        errors,
+        prefix: props.prefix,
+        actor: props.actor,
+        operation,
+        accessor: `$input.request.operations[${index}]`,
+      }),
+    );
+    if (errors.length !== 0) {
+      return {
+        success: false,
+        errors,
+        data: next,
+      };
+    }
+    return result;
+  };
+
+  const application: ILlmApplication = props.preliminary.fixApplication(
+    typia.llm.application<IAutoBeInterfaceAuthorizationApplication>({
+      validate: {
+        process: validate,
+      },
+    }),
+  );
+  return {
+    protocol: "class",
+    name: SOURCE,
+    application,
+    execute: {
+      process: (next) => {
+        if (next.request.type === "complete") {
+          for (const o of next.request.operations)
+            for (const p of o.parameters)
+              AutoBeJsonSchemaFactory.fixSchema(p.schema);
+          next.request.operations = next.request.operations.filter(
+            (operation) =>
+              AutoBeInterfaceAuthorizationProgrammer.filter({
+                actor: props.actor.kind,
+                operation,
+              }),
+          );
+          props.build(next.request);
+        }
+      },
+    } satisfies IAutoBeInterfaceAuthorizationApplication,
+  };
+}
+
+const SOURCE = "interfaceAuthorization" satisfies AutoBeEventSource;

package/src/orchestrate/interface/orchestrateInterfaceBaseEndpoint.ts

@@ -1,55 +1,55 @@
-import {
-  AutoBeInterfaceEndpointDesign,
-  AutoBeInterfaceGroup,
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-} from "@autobe/interface";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { transformInterfaceBaseEndpointReviewHistory } from "./histories/transformInterfaceBaseEndpointReviewHistory";
-import { transformInterfaceBaseEndpointWriteHistory } from "./histories/transformInterfaceBaseEndpointWriteHistory";
-import { orchestrateInterfaceEndpointOverall } from "./orchestrateInterfaceEndpointOverall";
-import { orchestrateInterfaceEndpointReview } from "./orchestrateInterfaceEndpointReview";
-
-export const orchestrateInterfaceBaseEndpoint = (
-  ctx: AutoBeContext,
-  props: {
-    instruction: string;
-    authorizeOperations: AutoBeOpenApi.IOperation[];
-    groups: AutoBeInterfaceGroup[];
-    reviewProgress: AutoBeProgressEventBase;
-    progress: AutoBeProgressEventBase;
-  },
-): Promise<AutoBeInterfaceEndpointDesign[]> =>
-  orchestrateInterfaceEndpointOverall(ctx, {
-    programmer: {
-      kind: "base",
-      history: (next) =>
-        transformInterfaceBaseEndpointWriteHistory({
-          state: ctx.state(),
-          authorizeOperations: props.authorizeOperations,
-          group: next.group,
-          instruction: props.instruction,
-          preliminary: next.preliminary,
-        }),
-      review: (next) =>
-        orchestrateInterfaceEndpointReview(ctx, {
-          programmer: {
-            kind: "base",
-            history: (future) =>
-              transformInterfaceBaseEndpointReviewHistory({
-                preliminary: future.preliminary,
-                designs: future.designs,
-                group: future.group,
-                authorizeOperations: props.authorizeOperations,
-              }),
-          },
-          group: next.group,
-          designs: next.designs,
-          promptCacheKey: next.promptCacheKey,
-          progress: props.reviewProgress,
-        }),
-    },
-    groups: props.groups,
-    progress: props.progress,
-  });
+import {
+  AutoBeInterfaceEndpointDesign,
+  AutoBeInterfaceGroup,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+} from "@autobe/interface";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { transformInterfaceBaseEndpointReviewHistory } from "./histories/transformInterfaceBaseEndpointReviewHistory";
+import { transformInterfaceBaseEndpointWriteHistory } from "./histories/transformInterfaceBaseEndpointWriteHistory";
+import { orchestrateInterfaceEndpointOverall } from "./orchestrateInterfaceEndpointOverall";
+import { orchestrateInterfaceEndpointReview } from "./orchestrateInterfaceEndpointReview";
+
+export const orchestrateInterfaceBaseEndpoint = (
+  ctx: AutoBeContext,
+  props: {
+    instruction: string;
+    authorizeOperations: AutoBeOpenApi.IOperation[];
+    groups: AutoBeInterfaceGroup[];
+    reviewProgress: AutoBeProgressEventBase;
+    progress: AutoBeProgressEventBase;
+  },
+): Promise<AutoBeInterfaceEndpointDesign[]> =>
+  orchestrateInterfaceEndpointOverall(ctx, {
+    programmer: {
+      kind: "base",
+      history: (next) =>
+        transformInterfaceBaseEndpointWriteHistory({
+          state: ctx.state(),
+          authorizeOperations: props.authorizeOperations,
+          group: next.group,
+          instruction: props.instruction,
+          preliminary: next.preliminary,
+        }),
+      review: (next) =>
+        orchestrateInterfaceEndpointReview(ctx, {
+          programmer: {
+            kind: "base",
+            history: (future) =>
+              transformInterfaceBaseEndpointReviewHistory({
+                preliminary: future.preliminary,
+                designs: future.designs,
+                group: future.group,
+                authorizeOperations: props.authorizeOperations,
+              }),
+          },
+          group: next.group,
+          designs: next.designs,
+          promptCacheKey: next.promptCacheKey,
+          progress: props.reviewProgress,
+        }),
+    },
+    groups: props.groups,
+    progress: props.progress,
+  });

package/src/orchestrate/interface/orchestrateInterfaceEndpoint.ts

@@ -1,67 +1,67 @@
-import {
-  AutoBeInterfaceEndpointDesign,
-  AutoBeInterfaceEndpointEvent,
-  AutoBeInterfaceGroup,
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-} from "@autobe/interface";
-import { AutoBeOpenApiEndpointComparator } from "@autobe/utils";
-import { HashMap, Pair } from "tstl";
-import typia from "typia";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { orchestrateInterfaceActionEndpoint } from "./orchestrateInterfaceActionEndpoint";
-import { orchestrateInterfaceBaseEndpoint } from "./orchestrateInterfaceBaseEndpoint";
-
-export const orchestrateInterfaceEndpoint = async (
-  ctx: AutoBeContext,
-  props: {
-    instruction: string;
-    authorizeOperations: AutoBeOpenApi.IOperation[];
-    groups: AutoBeInterfaceGroup[];
-  },
-): Promise<AutoBeInterfaceEndpointDesign[]> => {
-  const writeProgress: AutoBeProgressEventBase = {
-    completed: 0,
-    total: props.groups.length * ENDPOINT_STEPS,
-  };
-  const reviewProgress: AutoBeProgressEventBase = {
-    completed: 0,
-    total: props.groups.length * ENDPOINT_STEPS,
-  };
-
-  // BASE ENDPOINTS
-  const baseEndpoints: AutoBeInterfaceEndpointDesign[] =
-    await orchestrateInterfaceBaseEndpoint(ctx, {
-      instruction: props.instruction,
-      authorizeOperations: props.authorizeOperations,
-      groups: props.groups,
-      reviewProgress: reviewProgress,
-      progress: writeProgress,
-    });
-
-  // ACTION ENDPOINTS
-  const actionEndpoints: AutoBeInterfaceEndpointDesign[] =
-    await orchestrateInterfaceActionEndpoint(ctx, {
-      instruction: props.instruction,
-      authorizeOperations: props.authorizeOperations,
-      groups: props.groups,
-      baseEndpoints: baseEndpoints,
-      progress: writeProgress,
-      reviewProgress: reviewProgress,
-    });
-
-  // UNIQUE FILTERING
-  return new HashMap(
-    [...baseEndpoints, ...actionEndpoints].map(
-      (design) => new Pair(design.endpoint, design),
-    ),
-    AutoBeOpenApiEndpointComparator.hashCode,
-    AutoBeOpenApiEndpointComparator.equals,
-  )
-    .toJSON()
-    .map((it) => it.second);
-};
-
-const ENDPOINT_STEPS =
-  typia.misc.literals<AutoBeInterfaceEndpointEvent["kind"]>().length;
+import {
+  AutoBeInterfaceEndpointDesign,
+  AutoBeInterfaceEndpointEvent,
+  AutoBeInterfaceGroup,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+} from "@autobe/interface";
+import { AutoBeOpenApiEndpointComparator } from "@autobe/utils";
+import { HashMap, Pair } from "tstl";
+import typia from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { orchestrateInterfaceActionEndpoint } from "./orchestrateInterfaceActionEndpoint";
+import { orchestrateInterfaceBaseEndpoint } from "./orchestrateInterfaceBaseEndpoint";
+
+export const orchestrateInterfaceEndpoint = async (
+  ctx: AutoBeContext,
+  props: {
+    instruction: string;
+    authorizeOperations: AutoBeOpenApi.IOperation[];
+    groups: AutoBeInterfaceGroup[];
+  },
+): Promise<AutoBeInterfaceEndpointDesign[]> => {
+  const writeProgress: AutoBeProgressEventBase = {
+    completed: 0,
+    total: props.groups.length * ENDPOINT_STEPS,
+  };
+  const reviewProgress: AutoBeProgressEventBase = {
+    completed: 0,
+    total: props.groups.length * ENDPOINT_STEPS,
+  };
+
+  // BASE ENDPOINTS
+  const baseEndpoints: AutoBeInterfaceEndpointDesign[] =
+    await orchestrateInterfaceBaseEndpoint(ctx, {
+      instruction: props.instruction,
+      authorizeOperations: props.authorizeOperations,
+      groups: props.groups,
+      reviewProgress: reviewProgress,
+      progress: writeProgress,
+    });
+
+  // ACTION ENDPOINTS
+  const actionEndpoints: AutoBeInterfaceEndpointDesign[] =
+    await orchestrateInterfaceActionEndpoint(ctx, {
+      instruction: props.instruction,
+      authorizeOperations: props.authorizeOperations,
+      groups: props.groups,
+      baseEndpoints: baseEndpoints,
+      progress: writeProgress,
+      reviewProgress: reviewProgress,
+    });
+
+  // UNIQUE FILTERING
+  return new HashMap(
+    [...baseEndpoints, ...actionEndpoints].map(
+      (design) => new Pair(design.endpoint, design),
+    ),
+    AutoBeOpenApiEndpointComparator.hashCode,
+    AutoBeOpenApiEndpointComparator.equals,
+  )
+    .toJSON()
+    .map((it) => it.second);
+};
+
+const ENDPOINT_STEPS =
+  typia.misc.literals<AutoBeInterfaceEndpointEvent["kind"]>().length;