@autobe/agent 0.17.1 → 0.18.0

package/src/orchestrate/realize/RealizePipe.ts

@@ -1,39 +0,0 @@
-import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
-
-export function pipe<A, B>(
-  a: A,
-  ab: (a: A) => Promise<B | FAILED>,
-): Promise<B | FAILED>;
-
-export function pipe<A, B, C>(
-  a: A,
-  ab: (a: A) => Promise<B | FAILED>,
-  bc: (b: B) => Promise<C | FAILED>,
-): Promise<C | FAILED>;
-
-export function pipe<A, B, C, D>(
-  a: A,
-  ab: (a: A) => Promise<B | FAILED>,
-  bc: (b: B) => Promise<C | FAILED>,
-  cd: (c: C) => Promise<D | FAILED>,
-): Promise<D | FAILED>;
-
-export function pipe<A, B, C, D, E>(
-  a: A,
-  ab: (a: A) => Promise<B | FAILED>,
-  bc: (b: B) => Promise<C | FAILED>,
-  cd: (c: C) => Promise<D | FAILED>,
-  de: (d: D) => Promise<E | FAILED>,
-): Promise<E | FAILED>;
-
-export function pipe(
-  a: any,
-  ...fns: Array<(arg: any) => Promise<any>>
-): Promise<any> {
-  return fns.reduce((prev, fn) => {
-    return prev.then((result) => {
-      if (result === FAILED) return FAILED;
-      return fn(result);
-    });
-  }, Promise.resolve(a));
-}

package/src/orchestrate/realize/orchestrateRealizeCoder.ts

@@ -1,182 +0,0 @@
-import { IAgenticaController, MicroAgentica } from "@agentica/core";
-import {
-  AutoBeOpenApi,
-  AutoBeRealizeAuthorization,
-  IAutoBeTypeScriptCompileResult,
-} from "@autobe/interface";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
-import { IPointer } from "tstl";
-import typia from "typia";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { randomBackoffRetry } from "../../utils/backoffRetry";
-import { enforceToolCall } from "../../utils/enforceToolCall";
-import { getTestScenarioArtifacts } from "../test/compile/getTestScenarioArtifacts";
-import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
-import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
-import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
-import { IAutoBeRealizeCompile } from "./structures/IAutoBeRealizeCompile";
-import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
-import { transformRealizeCoderHistories } from "./transformRealizeCoderHistories";
-import { RealizeFileSystem } from "./utils/ProviderFileSystem";
-import { replaceImportStatements } from "./utils/replaceImportStatements";
-
-/**
- * Generates a TypeScript function implementation based on the given plan.
- *
- * This function transforms the plan (function name, input/output schema,
- * constraints, and scenarios) into a complete TypeScript function as a string.
- * It is responsible only for producing the code logic, and does not handle
- * imports, exports, or formatting.
- *
- * Import statements are handled separately and will be injected automatically.
- * Any unused imports will be removed by tooling (e.g. eslint).
- *
- * Type annotations should be omitted whenever possible to favor TypeScript's
- * type inference, unless explicit types are critical to correctness.
- *
- * @param ctx - AutoBE execution context
- * @param props - Planning result describing what function to generate
- * @returns The generated function name and TypeScript code
- */
-export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-  operation: AutoBeOpenApi.IOperation,
-  previousCodes: IAutoBeRealizeCompile.Success[],
-  props: RealizePlannerOutput,
-  previous: string | null,
-  total: IAutoBeTypeScriptCompileResult.IDiagnostic[],
-  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
-  authorization?: AutoBeRealizeAuthorization,
-): Promise<IAutoBeRealizeCoderApplication.RealizeCoderOutput | FAILED> => {
-  total;
-
-  const artifacts: IAutoBeTestScenarioArtifacts =
-    await getTestScenarioArtifacts(ctx, {
-      endpoint: {
-        method: operation.method,
-        path: operation.path,
-      },
-      dependencies: [],
-    });
-
-  const pointer: IPointer<Omit<
-    IAutoBeRealizeCoderApplication.RealizeCoderOutput,
-    "filename"
-  > | null> = {
-    value: null,
-  };
-
-  const controller = createApplication({
-    model: ctx.model,
-    build: (props) => {
-      pointer.value = props.output;
-    },
-  });
-
-  const agent = new MicroAgentica({
-    controllers: [controller],
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...ctx.config,
-      executor: {
-        describe: null,
-      },
-    },
-    histories: transformRealizeCoderHistories(
-      ctx.state(),
-      previousCodes,
-      props,
-      artifacts,
-      previous,
-      diagnostics,
-      authorization,
-    ),
-  });
-  enforceToolCall(agent);
-
-  await randomBackoffRetry(() =>
-    agent.conversate(
-      [
-        `Write complete, production-ready TypeScript code that strictly follows these rules:`,
-        "",
-        `1. Do **not** use the native \`Date\` type anywhere.`,
-        `2. All date or datetime values must be written as \`string & tags.Format<'date-time'>\`.`,
-        `3. UUIDs must be generated using \`v4()\` and typed as \`string & tags.Format<'uuid'>\`.`,
-        `4. Do not use \`as\` for type assertions — resolve types properly.`,
-        `5. All functions must be fully typed with clear parameter and return types.`,
-        `6. Do not skip validations or default values where necessary.`,
-        `7. Follow functional, immutable, and consistent code structure.`,
-        "",
-        `Use \`@nestia/e2e\` test structure if relevant.`,
-      ].join("\n"),
-    ),
-  ).finally(() => {
-    const tokenUsage = agent.getTokenUsage().aggregate;
-    ctx.usage().record(tokenUsage, ["realize"]);
-  });
-
-  if (pointer.value === null) {
-    return FAILED;
-  }
-
-  pointer.value.implementationCode = await replaceImportStatements(ctx)(
-    artifacts,
-    pointer.value.implementationCode,
-    props.decoratorEvent?.payload.name,
-  );
-
-  pointer.value.implementationCode =
-    pointer.value.implementationCode.replaceAll(
-      "typia.tags.assert",
-      "typia.assert",
-    );
-
-  return {
-    ...pointer.value,
-    filename: RealizeFileSystem.providerPath(props.functionName),
-  };
-};
-
-function createApplication<Model extends ILlmSchema.Model>(props: {
-  model: Model;
-  build: (next: IAutoBeRealizeCoderApplication.IProps) => void;
-}): IAgenticaController.IClass<Model> {
-  assertSchemaModel(props.model);
-
-  const application: ILlmApplication<Model> = collection[
-    props.model
-  ] as unknown as ILlmApplication<Model>;
-
-  return {
-    protocol: "class",
-    name: "Write code",
-    application,
-    execute: {
-      programming: (next) => {
-        props.build(next);
-      },
-    } satisfies IAutoBeRealizeCoderApplication,
-  };
-}
-
-const claude = typia.llm.application<
-  IAutoBeRealizeCoderApplication,
-  "claude",
-  {
-    reference: true;
-  }
->();
-const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeRealizeCoderApplication,
-    "chatgpt",
-    { reference: true }
-  >(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
-};

package/src/orchestrate/realize/writeCodeUntilCompilePassed.ts

@@ -1,308 +0,0 @@
-import {
-  AutoBeOpenApi,
-  AutoBeRealizeAuthorization,
-  AutoBeRealizeFunction,
-  IAutoBeTypeScriptCompileResult,
-} from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-import { HashMap } from "tstl";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { ProviderCodeComparator } from "./ProviderCodeComparator";
-import { pipe } from "./RealizePipe";
-import { orchestrateRealizeCoder } from "./orchestrateRealizeCoder";
-import {
-  RealizePlannerOutput,
-  orchestrateRealizePlanner,
-} from "./orchestrateRealizePlanner";
-import { IAutoBeRealizeCompile } from "./structures/IAutoBeRealizeCompile";
-import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
-import { RealizeFileSystem } from "./utils/ProviderFileSystem";
-
-export function writeCodeUntilCompilePassed<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-) {
-  return async function (props: {
-    operations: AutoBeOpenApi.IOperation[];
-    authorizations: AutoBeRealizeAuthorization[];
-    retry: number;
-  }): Promise<{
-    compiled: IAutoBeTypeScriptCompileResult;
-    functions: AutoBeRealizeFunction[];
-  }> {
-    const payloads: Record<string, string> = Object.fromEntries(
-      props.authorizations.map((el) => [
-        el.payload.location,
-        el.payload.content,
-      ]),
-    );
-
-    const files: Record<string, string> = Object.fromEntries(
-      Object.entries(await ctx.files({ dbms: "postgres" })).filter(([key]) =>
-        key.startsWith("src"),
-      ),
-    );
-
-    const templateFiles = await getTemplates(ctx);
-
-    let diagnostics: IAutoBeRealizeCompile.CompileDiagnostics = {
-      current: [],
-      total: [],
-    };
-
-    const histories: HashMap<
-      AutoBeOpenApi.IEndpoint,
-      IAutoBeRealizeCompile.Success[]
-    > = new HashMap(
-      ProviderCodeComparator.hashCode,
-      ProviderCodeComparator.equals,
-    );
-
-    for (const operation of props.operations) {
-      histories.set(operation, []);
-    }
-
-    let compiled: IAutoBeTypeScriptCompileResult | null = null;
-    const entireCodes: IAutoBeRealizeCompile.FileContentMap = {};
-    for (let i = 0; i < props.retry; i++) {
-      const targets = props.operations.filter((op) =>
-        shouldProcessOperation(op, diagnostics.current),
-      );
-
-      const metadata = { total: targets.length, count: 0 } as const;
-      const generatedCodes = await Promise.all(
-        targets.map((operation) => {
-          const role: string | null = operation.authorizationRole;
-          const authorization: AutoBeRealizeAuthorization | undefined =
-            props.authorizations.find((el) => el.role === role);
-
-          return process(ctx)({
-            metadata,
-            operation,
-            previousCodes: histories.get(operation),
-            diagnostics,
-            entireCodes,
-            authorization,
-          });
-        }),
-      );
-
-      for (const code of generatedCodes) {
-        if (code.type === "success") {
-          const response = histories.get(code.operation);
-          response.push(code);
-          histories.set(code.operation, response);
-
-          entireCodes[code.result.filename] = {
-            content: code.result.implementationCode,
-            result: "success",
-            endpoint: {
-              method: code.operation.method,
-              path: code.operation.path,
-            },
-            location: code.result.filename,
-            name: code.result.name,
-          };
-        }
-      }
-
-      const prisma = ctx.state().prisma?.compiled;
-      const nodeModules = prisma?.type === "success" ? prisma.nodeModules : {};
-      const compiler = await ctx.compiler();
-      compiled = await compiler.typescript.compile({
-        files: {
-          ...payloads,
-          ...files,
-          ...nodeModules,
-          ...Object.fromEntries(
-            templateFiles.map((file) => [file.location, file.content]),
-          ),
-          ...Object.fromEntries(
-            Object.entries(entireCodes).map(([filename, { content }]) => [
-              filename,
-              content,
-            ]),
-          ),
-        },
-      });
-
-      if (compiled && compiled.type !== "success") {
-        ctx.dispatch({
-          type: "realizeValidate",
-          created_at: new Date().toISOString(),
-          files:
-            compiled.type === "failure"
-              ? Object.fromEntries(
-                  compiled.diagnostics.map((diagnostic) => [
-                    diagnostic.file,
-                    diagnostic.code,
-                  ]),
-                )
-              : {},
-          result: compiled,
-          step: ctx.state().analyze?.step ?? 0,
-        });
-      }
-
-      if (
-        compiled.type === "success" &&
-        generatedCodes.every((c) => c.type === "success")
-      ) {
-        break;
-      } else if (compiled.type === "failure") {
-        diagnostics.current = compiled.diagnostics;
-        diagnostics.total = [...diagnostics.total, ...compiled.diagnostics];
-      }
-    }
-
-    const functions = Object.entries(entireCodes)
-      .filter(([filename]) => filename.startsWith("src/providers")) // filter only provider files
-      .map(([filename, value]) => {
-        return {
-          filename,
-          content: value.content,
-          endpoint: value.endpoint!,
-          location: value.location!,
-          name: value.name!,
-          role: value.role ?? null,
-        };
-      });
-
-    return { functions, compiled: compiled ? compiled : { type: "success" } };
-  };
-}
-
-/**
- * Loads template files for the realize agent These files are essential for the
- * realize coder to pass compilation
- *
- * @param ctx Context of agent
- * @returns Template file infomations
- */
-async function getTemplates<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-): Promise<IAutoBeRealizeCompile.CodeArtifact[]> {
-  const compiler = await ctx.compiler();
-  const templateFiles = await compiler.realize.getTemplate();
-  const pathnames = ["src/MyGlobal.ts", "src/util/toISOStringSafe.ts"] as const;
-
-  return pathnames.map((pathname): IAutoBeRealizeCompile.CodeArtifact => {
-    return {
-      content: templateFiles[pathname],
-      result: "success",
-      location: pathname,
-      role: null, // template files doesn't have role.
-    } as const;
-  });
-}
-
-function process<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) {
-  return async function (props: {
-    metadata: { total: number; count: number };
-    operation: AutoBeOpenApi.IOperation;
-    previousCodes: IAutoBeRealizeCompile.Success[];
-    diagnostics: IAutoBeRealizeCompile.CompileDiagnostics;
-    entireCodes: IAutoBeRealizeCompile.FileContentMap;
-    authorization?: AutoBeRealizeAuthorization;
-  }) {
-    const result = await pipe(
-      props.operation,
-      (operation: AutoBeOpenApi.IOperation) =>
-        orchestrateRealizePlanner(ctx, operation, props.authorization),
-      async (plan: RealizePlannerOutput) => {
-        const filename = RealizeFileSystem.providerPath(plan.functionName);
-        const totalDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[] =
-          props.diagnostics.total.filter((el) => el.file === filename);
-        const currentDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[] =
-          props.diagnostics.current.filter((el) => el.file === filename);
-        const code = props.entireCodes[filename]?.content ?? null;
-
-        return orchestrateRealizeCoder(
-          ctx,
-          props.operation,
-          props.previousCodes,
-          plan,
-          code,
-          totalDiagnostics,
-          currentDiagnostics,
-          props.authorization,
-        ).then((res) => {
-          if (props.previousCodes.length === 0) {
-            ctx.dispatch({
-              type: "realizeWrite",
-              filename: filename,
-              content: res === FAILED ? "FAILED" : res.implementationCode,
-              completed: ++props.metadata.count,
-              created_at: new Date().toISOString(),
-              step: ctx.state().analyze?.step ?? 0,
-              total: props.metadata.total,
-            });
-          } else {
-            ctx.dispatch({
-              type: "realizeCorrect",
-              filename: filename,
-              content: res === FAILED ? "FAILED" : res.implementationCode,
-              completed: ++props.metadata.count,
-              created_at: new Date().toISOString(),
-              step: ctx.state().analyze?.step ?? 0,
-              total: props.metadata.total,
-            });
-          }
-
-          if (res === FAILED) {
-            return res;
-          }
-
-          return { ...res, name: plan.functionName };
-        });
-      },
-    );
-
-    if (result === FAILED) {
-      return { type: "failed", operation: props.operation, result } as const;
-    }
-
-    return { type: "success", operation: props.operation, result } as const;
-  };
-}
-
-/**
- * Determines whether an operation should be processed in the current iteration.
- * In the initial case (no errors), all operations are processed. When errors
- * exist, only operations with compilation errors are targeted for reprocessing
- * in the next iteration.
- *
- * @param op - The operation to check
- * @param currentDiagnostics - Current compilation errors
- * @returns True if the operation should be processed
- */
-function shouldProcessOperation(
-  op: AutoBeOpenApi.IOperation,
-  currentDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
-): boolean {
-  if (currentDiagnostics.length === 0) {
-    return true;
-  }
-
-  const operationFilename = generateProviderFilename(op);
-
-  return currentDiagnostics.some(
-    (diagnostic) => diagnostic.file === operationFilename,
-  );
-}
-
-/**
- * Generates a provider filename for an operation. Converts the operation's HTTP
- * method and path into a valid TypeScript filename. The filename serves as both
- * the function name and the file identifier.
- *
- * @param op - The operation to generate a filename for
- * @returns The generated provider filename with path
- */
-function generateProviderFilename(op: AutoBeOpenApi.IOperation): string {
-  return `src/providers/${op.method}_${op.path
-    .replaceAll("/", "_")
-    .replaceAll("-", "_")
-    .replaceAll("{", "$")
-    .replaceAll("}", "")}.ts`;
-}

package/src/orchestrate/test/transformTestScenarioHistories.ts

@@ -1,105 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { v4 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../context/AutoBeState";
-
-export const transformTestScenarioHistories = (
-  state: AutoBeState,
-): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => {
-  if (state.analyze === null)
-    return [
-      {
-        id: v4(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: [
-          "Requirement analysis is not yet completed.",
-          "Don't call the any tool function,",
-          "but say to process the requirement analysis.",
-        ].join(" "),
-      },
-    ];
-  else if (state.prisma === null)
-    return [
-      {
-        id: v4(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: [
-          "Prisma DB schema generation is not yet completed.",
-          "Don't call the any tool function,",
-          "but say to process the Prisma DB schema generation.",
-        ].join(" "),
-      },
-    ];
-  else if (state.analyze.step !== state.prisma.step)
-    return [
-      {
-        id: v4(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: [
-          "Prisma DB schema generation has not been updated",
-          "for the latest requirement analysis.",
-          "Don't call the any tool function,",
-          "but say to re-process the Prisma DB schema generation.",
-        ].join(" "),
-      },
-    ];
-  else if (state.prisma.compiled.type !== "success")
-    return [
-      {
-        id: v4(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: [
-          "Prisma DB schema generation has not been updated",
-          "for the latest requirement analysis.",
-          "Don't call the any tool function,",
-          "but say to re-process the Prisma DB schema generation.",
-        ].join(" "),
-      },
-    ];
-  else if (state.interface === null)
-    return [
-      {
-        id: v4(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: [
-          "Interface generation is not yet completed.",
-          "Don't call the any tool function,",
-          "but say to process the interface generation.",
-        ].join(" "),
-      },
-    ];
-
-  return [
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.TEST,
-    },
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: [
-        "# Result of Interfaced Agent",
-        "- OpenAPI document generation is ready.",
-        "",
-        "Call the provided tool function to generate the user scenarios",
-        "referencing below OpenAPI document.",
-        "",
-        `## OpenAPI Document`,
-        "```json",
-        JSON.stringify(state.interface.document),
-        "```",
-      ].join("\n"),
-    },
-  ];
-};

package/src/utils/enforceToolCall.ts

@@ -1,13 +0,0 @@
-import { MicroAgentica } from "@agentica/core";
-import { ILlmSchema } from "@samchon/openapi";
-
-export function enforceToolCall<Model extends ILlmSchema.Model>(
-  agent: MicroAgentica<Model>,
-): MicroAgentica<Model> {
-  agent.on("request", (event) => {
-    if (event.body.tools) event.body.tool_choice = "required";
-    if (event.body.parallel_tool_calls !== undefined)
-      delete event.body.parallel_tool_calls;
-  });
-  return agent;
-}

package/src/utils/forceRetry.ts

@@ -1,13 +0,0 @@
-export async function forceRetry<T>(
-  task: () => Promise<T>,
-  count: number = 2,
-): Promise<T> {
-  let error: unknown = undefined;
-  for (let i: number = 0; i <= count; ++i)
-    try {
-      return await task();
-    } catch (e) {
-      error = e;
-    }
-  throw error;
-}