@autobe/agent 0.28.1 → 0.29.1

package/src/orchestrate/realize/orchestrateRealizeAuthorizationCorrect.ts

@@ -1,18 +1,20 @@
 import { IAgenticaController } from "@agentica/core";
 import {
+  AutoBeEventSource,
   AutoBeRealizeAuthorization,
   AutoBeRealizeAuthorizationCorrect,
   IAutoBeCompiler,
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+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 { assertSchemaModel } from "../../context/assertSchemaModel";
-import { transformRealizeAuthorizationCorrectHistories } from "./histories/transformRealizeAuthorizationCorrectHistories";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformRealizeAuthorizationCorrectHistory } from "./histories/transformRealizeAuthorizationCorrectHistory";
 import { IAutoBeRealizeAuthorizationCorrectApplication } from "./structures/IAutoBeRealizeAuthorizationCorrectApplication";
 import { AuthorizationFileSystem } from "./utils/AuthorizationFileSystem";
 import { AutoBeRealizeAuthorizationReplaceImport } from "./utils/AutoBeRealizeAuthorizationReplaceImport";
@@ -21,35 +23,37 @@ export async function orchestrateRealizeAuthorizationCorrect<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  authorization: AutoBeRealizeAuthorization,
-  prismaClients: Record<string, string>,
-  templateFiles: Record<string, string>,
+  props: {
+    authorization: AutoBeRealizeAuthorization;
+    template: Record<string, string>;
+    prismaClient: Record<string, string>;
+  },
   life: number = ctx.retry,
 ): Promise<AutoBeRealizeAuthorization> {
   const compiler: IAutoBeCompiler = await ctx.compiler();
   const providerContent: string = await compiler.typescript.beautify(
     AutoBeRealizeAuthorizationReplaceImport.replaceProviderImport(
-      authorization.actor.name,
-      authorization.provider.content,
+      props.authorization.actor.name,
+      props.authorization.provider.content,
     ),
   );
   const decoratorContent: string = await compiler.typescript.beautify(
     AutoBeRealizeAuthorizationReplaceImport.replaceDecoratorImport(
-      authorization.actor.name,
-      authorization.decorator.content,
+      props.authorization.actor.name,
+      props.authorization.decorator.content,
     ),
   );
 
   // Check Compile
   const files: Record<string, string> = {
-    ...templateFiles,
-    ...prismaClients,
-    [AuthorizationFileSystem.decoratorPath(authorization.decorator.name)]:
+    ...props.template,
+    ...props.prismaClient,
+    [AuthorizationFileSystem.decoratorPath(props.authorization.decorator.name)]:
       decoratorContent,
-    [AuthorizationFileSystem.providerPath(authorization.provider.name)]:
+    [AuthorizationFileSystem.providerPath(props.authorization.provider.name)]:
       providerContent,
-    [AuthorizationFileSystem.payloadPath(authorization.payload.name)]:
-      authorization.payload.content,
+    [AuthorizationFileSystem.payloadPath(props.authorization.payload.name)]:
+      props.authorization.payload.content,
   };
 
   const compiled: IAutoBeTypeScriptCompileResult =
@@ -61,121 +65,175 @@ export async function orchestrateRealizeAuthorizationCorrect<
     type: "realizeAuthorizationValidate",
     id: v7(),
     created_at: new Date().toISOString(),
-    authorization: authorization,
+    authorization: props.authorization,
     result: compiled,
     step: ctx.state().test?.step ?? 0,
   });
 
   if (compiled.type === "success") {
-    return authorization;
+    return props.authorization;
   } else if (compiled.type === "exception" || life < 0) {
-    return authorization;
+    return props.authorization;
   }
 
-  const pointer: IPointer<IAutoBeRealizeAuthorizationCorrectApplication.IProps | null> =
-    {
-      value: null,
-    };
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "realizeAuthorizationCorrect",
-    histories: transformRealizeAuthorizationCorrectHistories(
-      ctx,
-      authorization,
-      templateFiles,
-      compiled.diagnostics,
-    ),
-    controller: createController({
-      model: ctx.model,
-      build: (next) => {
-        pointer.value = next;
+  const preliminary: AutoBePreliminaryController<"prismaSchemas"> =
+    new AutoBePreliminaryController({
+      source: SOURCE,
+      application:
+        typia.json.application<IAutoBeRealizeAuthorizationCorrectApplication>(),
+      kinds: ["prismaSchemas"],
+      state: ctx.state(),
+    });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeRealizeAuthorizationCorrectApplication.IComplete | null> =
+      {
+        value: null,
+      };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: "realizeAuthorizationCorrect",
+      controller: createController({
+        model: ctx.model,
+        build: (next) => {
+          pointer.value = next;
+        },
+        preliminary,
+      }),
+      enforceFunctionCall: true,
+      ...transformRealizeAuthorizationCorrectHistory({
+        authorization: props.authorization,
+        template: props.template,
+        diagnostics: compiled.diagnostics,
+        preliminary,
+      }),
+    });
+    if (pointer.value === null) return out(result)(null);
+
+    const correct: AutoBeRealizeAuthorizationCorrect = {
+      ...pointer.value,
+      decorator: {
+        ...pointer.value.decorator,
+        location: AuthorizationFileSystem.decoratorPath(
+          pointer.value.decorator.name,
+        ),
       },
-    }),
-    enforceFunctionCall: true,
-    message: "Please correct the decorator and the provider.",
-  });
-  if (pointer.value === null) throw new Error("Failed to correct decorator.");
+      provider: {
+        ...pointer.value.provider,
+        location: AuthorizationFileSystem.providerPath(
+          pointer.value.provider.name,
+        ),
+      },
+      payload: {
+        name: pointer.value.payload.name,
+        location: AuthorizationFileSystem.payloadPath(
+          pointer.value.payload.name,
+        ),
+        content: await compiler.typescript.beautify(
+          pointer.value.payload.content,
+        ),
+      },
+      actor: props.authorization.actor,
+    };
 
-  const result: AutoBeRealizeAuthorizationCorrect = {
-    ...pointer.value,
-    decorator: {
-      ...pointer.value.decorator,
-      location: AuthorizationFileSystem.decoratorPath(
-        pointer.value.decorator.name,
-      ),
-    },
-    provider: {
-      ...pointer.value.provider,
-      location: AuthorizationFileSystem.providerPath(
-        pointer.value.provider.name,
-      ),
-    },
-    payload: {
-      name: pointer.value.payload.name,
-      location: AuthorizationFileSystem.payloadPath(pointer.value.payload.name),
-      content: await compiler.typescript.beautify(
-        pointer.value.payload.content,
+    ctx.dispatch({
+      ...pointer.value,
+      type: "realizeAuthorizationCorrect",
+      id: v7(),
+      created_at: new Date().toISOString(),
+      authorization: correct,
+      result: compiled,
+      metric: result.metric,
+      tokenUsage: result.tokenUsage,
+      step: ctx.state().test?.step ?? 0,
+    });
+    return out(result)(
+      await orchestrateRealizeAuthorizationCorrect(
+        ctx,
+        {
+          authorization: correct,
+          prismaClient: props.prismaClient,
+          template: props.template,
+        },
+        life - 1,
       ),
-    },
-    actor: authorization.actor,
-  };
-
-  ctx.dispatch({
-    ...pointer.value,
-    type: "realizeAuthorizationCorrect",
-    id: v7(),
-    created_at: new Date().toISOString(),
-    authorization: result,
-    result: compiled,
-    metric,
-    tokenUsage,
-    step: ctx.state().test?.step ?? 0,
+    );
   });
-
-  return await orchestrateRealizeAuthorizationCorrect(
-    ctx,
-    result,
-    prismaClients,
-    templateFiles,
-    life - 1,
-  );
 }
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  build: (next: IAutoBeRealizeAuthorizationCorrectApplication.IProps) => void;
+  build: (
+    next: IAutoBeRealizeAuthorizationCorrectApplication.IComplete,
+  ) => void;
+  preliminary: AutoBePreliminaryController<"prismaSchemas">;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
+  const validate: Validator = (input) => {
+    const result: IValidation<IAutoBeRealizeAuthorizationCorrectApplication.IProps> =
+      typia.validate<IAutoBeRealizeAuthorizationCorrectApplication.IProps>(
+        input,
+      );
+    if (result.success === false || result.data.request.type === "complete")
+      return result;
+    return props.preliminary.validate({
+      thinking: result.data.thinking,
+      request: result.data.request,
+    });
+  };
+
   const application: ILlmApplication<Model> = collection[
     props.model === "chatgpt"
       ? "chatgpt"
       : props.model === "gemini"
         ? "gemini"
         : "claude"
-  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
-    name: "Correct Authorization",
+    name: SOURCE,
     application,
     execute: {
-      correctDecorator: (next) => {
-        props.build(next);
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
       },
     } satisfies IAutoBeRealizeAuthorizationCorrectApplication,
   };
 }
 
 const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeRealizeAuthorizationCorrectApplication,
-    "chatgpt"
-  >(),
-  claude: typia.llm.application<
-    IAutoBeRealizeAuthorizationCorrectApplication,
-    "claude"
-  >(),
-  gemini: typia.llm.application<
-    IAutoBeRealizeAuthorizationCorrectApplication,
-    "gemini"
-  >(),
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<
+      IAutoBeRealizeAuthorizationCorrectApplication,
+      "chatgpt"
+    >({
+      validate: {
+        process: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<
+      IAutoBeRealizeAuthorizationCorrectApplication,
+      "claude"
+    >({
+      validate: {
+        process: validate,
+      },
+    }),
+  gemini: (validate: Validator) =>
+    typia.llm.application<
+      IAutoBeRealizeAuthorizationCorrectApplication,
+      "gemini"
+    >({
+      validate: {
+        process: validate,
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeRealizeAuthorizationCorrectApplication.IProps>;
+
+const SOURCE = "realizeAuthorizationCorrect" satisfies AutoBeEventSource;

package/src/orchestrate/realize/orchestrateRealizeAuthorizationWrite.ts

@@ -0,0 +1,241 @@
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeAnalyzeActor,
+  AutoBeEventSource,
+  AutoBeProgressEventBase,
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeAuthorizationWriteEvent,
+  IAutoBeCompiler,
+  IAutoBePrismaCompileResult,
+} 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 { assertSchemaModel } from "../../context/assertSchemaModel";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformRealizeAuthorizationWriteHistory } from "./histories/transformRealizeAuthorizationWriteHistory";
+import { orchestrateRealizeAuthorizationCorrect } from "./orchestrateRealizeAuthorizationCorrect";
+import { IAutoBeRealizeAuthorizationWriteApplication } from "./structures/IAutoBeRealizeAuthorizationWriteApplication";
+import { AuthorizationFileSystem } from "./utils/AuthorizationFileSystem";
+import { InternalFileSystem } from "./utils/InternalFileSystem";
+
+/**
+ * 1. Create decorator and its parameters. and design the Authorization Provider.
+ * 2. According to Authorization Provider design, create the Provider.
+ *
+ * @param ctx
+ */
+export async function orchestrateRealizeAuthorizationWrite<
+  Model extends ILlmSchema.Model,
+>(ctx: AutoBeContext<Model>): Promise<AutoBeRealizeAuthorization[]> {
+  ctx.dispatch({
+    type: "realizeAuthorizationStart",
+    id: v7(),
+    step: ctx.state().test?.step ?? 0,
+    created_at: new Date().toISOString(),
+  });
+
+  const actors: AutoBeAnalyzeActor[] = ctx.state().analyze?.actors ?? [];
+  const progress: AutoBeProgressEventBase = {
+    total: actors.length,
+    completed: 0,
+  };
+  const templates: Record<string, string> = await (
+    await ctx.compiler()
+  ).realize.getTemplate({
+    dbms: "sqlite",
+  });
+  const authorizations: AutoBeRealizeAuthorization[] = await executeCachedBatch(
+    ctx,
+    actors.map(
+      (a) => (promptCacheKey) =>
+        process(ctx, {
+          actor: a,
+          templates: InternalFileSystem.DEFAULT.map((el) => ({
+            [el]: templates[el],
+          })).reduce((acc, cur) => Object.assign(acc, cur), {}),
+          progress,
+          promptCacheKey,
+        }),
+    ),
+  );
+  ctx.dispatch({
+    type: "realizeAuthorizationComplete",
+    id: v7(),
+    created_at: new Date().toISOString(),
+    step: ctx.state().test?.step ?? 0,
+  });
+  return authorizations;
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    actor: AutoBeAnalyzeActor;
+    templates: Record<string, string>;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+  },
+): Promise<AutoBeRealizeAuthorization> {
+  const preliminary: AutoBePreliminaryController<"prismaSchemas"> =
+    new AutoBePreliminaryController<"prismaSchemas">({
+      source: SOURCE,
+      application:
+        typia.json.application<IAutoBeRealizeAuthorizationWriteApplication>(),
+      kinds: ["prismaSchemas"],
+      state: ctx.state(),
+    });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeRealizeAuthorizationWriteApplication.IComplete | null> =
+      {
+        value: null,
+      };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: "realizeAuthorizationWrite",
+      controller: createController({
+        model: ctx.model,
+        build: (next) => {
+          pointer.value = next;
+        },
+        preliminary,
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformRealizeAuthorizationWriteHistory({
+        actor: props.actor,
+        preliminary,
+      }),
+    });
+    if (pointer.value === null) return out(result)(null);
+
+    const compiler: IAutoBeCompiler = await ctx.compiler();
+    const authorization: AutoBeRealizeAuthorization = {
+      actor: props.actor,
+      decorator: {
+        location: AuthorizationFileSystem.decoratorPath(
+          pointer.value.decorator.name,
+        ),
+        name: pointer.value.decorator.name,
+        content: pointer.value.decorator.content,
+      },
+      payload: {
+        location: AuthorizationFileSystem.payloadPath(
+          pointer.value.payload.name,
+        ),
+        name: pointer.value.payload.name,
+        content: await compiler.typescript.beautify(
+          pointer.value.payload.content,
+        ),
+      },
+      provider: {
+        location: AuthorizationFileSystem.providerPath(
+          pointer.value.provider.name,
+        ),
+        name: pointer.value.provider.name,
+        content: pointer.value.provider.content,
+      },
+    };
+    ctx.dispatch({
+      type: "realizeAuthorizationWrite",
+      id: v7(),
+      created_at: new Date().toISOString(),
+      authorization: authorization,
+      metric: result.metric,
+      tokenUsage: result.tokenUsage,
+      completed: ++props.progress.completed,
+      total: props.progress.total,
+      step: ctx.state().test?.step ?? 0,
+    } satisfies AutoBeRealizeAuthorizationWriteEvent);
+
+    const prismaCompiled: IAutoBePrismaCompileResult | undefined =
+      ctx.state().prisma?.compiled;
+    const prismaClient: Record<string, string> =
+      prismaCompiled?.type === "success" ? prismaCompiled.nodeModules : {};
+    return out(result)(
+      await orchestrateRealizeAuthorizationCorrect(ctx, {
+        template: props.templates,
+        authorization,
+        prismaClient,
+      }),
+    );
+  });
+}
+
+function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (next: IAutoBeRealizeAuthorizationWriteApplication.IComplete) => void;
+  preliminary: AutoBePreliminaryController<"prismaSchemas">;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const validate: Validator = (input) => {
+    const result: IValidation<IAutoBeRealizeAuthorizationWriteApplication.IProps> =
+      typia.validate<IAutoBeRealizeAuthorizationWriteApplication.IProps>(input);
+    if (result.success === false || result.data.request.type === "complete")
+      return result;
+    return props.preliminary.validate({
+      thinking: result.data.thinking,
+      request: result.data.request,
+    });
+  };
+  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: SOURCE,
+    application,
+    execute: {
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
+      },
+    } satisfies IAutoBeRealizeAuthorizationWriteApplication,
+  };
+}
+
+const collection = {
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<
+      IAutoBeRealizeAuthorizationWriteApplication,
+      "chatgpt"
+    >({
+      validate: {
+        process: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<
+      IAutoBeRealizeAuthorizationWriteApplication,
+      "claude"
+    >({
+      validate: {
+        process: validate,
+      },
+    }),
+  gemini: (validate: Validator) =>
+    typia.llm.application<
+      IAutoBeRealizeAuthorizationWriteApplication,
+      "gemini"
+    >({
+      validate: {
+        process: validate,
+      },
+    }),
+};
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeRealizeAuthorizationWriteApplication.IProps>;
+
+const SOURCE = "realizeAuthorizationWrite" satisfies AutoBeEventSource;