@autobe/agent 0.17.1 → 0.19.1

package/src/orchestrate/realize/transformRealizeCoderHistories.ts

@@ -1,248 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import {
-  AutoBeRealizeAuthorization,
-  IAutoBeTypeScriptCompileResult,
-} from "@autobe/interface";
-import { v4 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../context/AutoBeState";
-import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
-import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
-import { IAutoBeRealizeCompile } from "./structures/IAutoBeRealizeCompile";
-
-export const transformRealizeCoderHistories = (
-  state: AutoBeState,
-  previousCodes: IAutoBeRealizeCompile.Success[],
-  props: RealizePlannerOutput,
-  artifacts: IAutoBeTestScenarioArtifacts,
-  previous: string | null,
-  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
-  authorization?: AutoBeRealizeAuthorization,
-): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => {
-  const [operation] = artifacts.document.operations;
-
-  const propsFields: string[] = [];
-
-  // payload 추가
-  if (authorization && operation.authorizationRole) {
-    propsFields.push(
-      `${operation.authorizationRole}: ${authorization.payload.name};`,
-    );
-  }
-
-  // parameters 추가
-  operation.parameters.forEach((parameter) => {
-    const format =
-      "format" in parameter.schema
-        ? ` & tags.Format<'${parameter.schema.format}'>`
-        : "";
-    propsFields.push(`${parameter.name}: ${parameter.schema.type}${format};`);
-  });
-
-  // body 추가
-  if (operation.requestBody?.typeName) {
-    propsFields.push(`body: ${operation.requestBody.typeName};`);
-  }
-
-  const input =
-    propsFields.length > 0
-      ? `props: {\n${propsFields.map((field) => `  ${field}`).join("\n")}\n}`
-      : `// No props parameter needed - function should have no parameters`;
-
-  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.REALIZE_CODER_TOTAL,
-    },
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.REALIZE_CODER_ARTIFACT.replaceAll(
-        `{prisma_schemas}`,
-        JSON.stringify(state.prisma.schemas),
-      )
-        .replaceAll(`{artifacts_sdk}`, JSON.stringify(artifacts.sdk))
-        .replaceAll(`{artifacts_dto}`, JSON.stringify(artifacts.dto))
-        .replaceAll(`{input}`, input),
-    },
-    ...(previous !== null
-      ? [
-          {
-            id: v4(),
-            created_at: new Date().toISOString(),
-            type: "assistantMessage",
-            text: [
-              "These values contain previously generated code and thought flow.",
-              "All of these codes are failed compilation values.",
-              previousCodes.length >= 2
-                ? "🚨 CRITICAL: You have already failed " +
-                  previousCodes.length +
-                  " times. The current approach is FUNDAMENTALLY WRONG!"
-                : "Please refer to the code for writing a new code.",
-              previousCodes.length >= 2
-                ? [
-                    "",
-                    "After multiple failures, you MUST make AGGRESSIVE changes:",
-                    "1. COMPLETELY REWRITE the problematic parts - don't just tweak",
-                    "2. Try a DIFFERENT algorithm or approach entirely",
-                    "3. Question ALL your assumptions about the requirements",
-                    "4. Consider alternative Prisma patterns or query structures",
-                    "5. The error might be in your fundamental understanding - rethink everything",
-                  ].join("\n")
-                : "",
-              "",
-              "```json",
-              JSON.stringify(
-                previousCodes.map((c) => c.result.implementationCode),
-              ),
-              "```",
-            ]
-              .filter(Boolean)
-              .join("\n"),
-          } as const,
-          {
-            id: v4(),
-            created_at: new Date().toISOString(),
-            type: "assistantMessage",
-            text: AutoBeSystemPromptConstant.REALIZE_CODER_DIAGNOSTICS.replaceAll(
-              `{code}`,
-              previous,
-            ).replaceAll("{current_diagnostics}", JSON.stringify(diagnostics)),
-          } as const,
-          {
-            id: v4(),
-            created_at: new Date().toISOString(),
-            type: "systemMessage",
-            text: [
-              "Modify the previous code to reflect the following operation.",
-              "```json",
-              JSON.stringify(props),
-              "```",
-            ].join("\n"),
-          } as const,
-        ]
-      : [
-          {
-            id: v4(),
-            created_at: new Date().toISOString(),
-            type: "systemMessage",
-            text: [
-              "Write new code based on the following operation.",
-              "```json",
-              JSON.stringify(props),
-              "```",
-            ].join("\n"),
-          } as const,
-        ]),
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: [
-        `I understand your request.`,
-        ``,
-        `To summarize:`,
-        `- I must **never use the native \`Date\` type** in any code or type definitions.`,
-        `- Instead, all date and datetime values must be handled as \`string & tags.Format<'date-time'>\`.`,
-        `- This rule is **strict** and applies everywhere, including domain types, API inputs/outputs, and Prisma models.`,
-        `- Even if a library or tool returns a \`Date\`, I must convert it to the correct string format before use.`,
-        ``,
-        `Especially regarding the \`Date\` type: I understand that using it can lead to type inconsistency and runtime issues, so I will completely avoid it in all circumstances.`,
-        ``,
-        `I'll make sure to follow all these rules strictly. Let’s proceed with this in mind.`,
-      ].join("\n"),
-    },
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: [
-        `I understand your request.`,
-        ``,
-        `To summarize:`,
-        `- I must **never use the native \`Date\` type** in any code or type definitions.`,
-        `- Instead, all date and datetime values must be handled as \`string & tags.Format<'date-time'>\`.`,
-        `- This rule is **strict** and applies everywhere, including domain types, API inputs/outputs, and Prisma models.`,
-        `- Even if a library or tool returns a \`Date\`, I must convert it to the correct string format before use.`,
-        ``,
-        `Especially regarding the \`Date\` type: I understand that using it can lead to type inconsistency and runtime issues, so I will completely avoid it in all circumstances.`,
-        ``,
-        `I'll make sure to follow all these rules strictly. Let’s proceed with this in mind.`,
-      ].join("\n"),
-    },
-  ];
-};

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;
-}