@autobe/agent 0.9.2 → 0.10.1

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -0,0 +1,129 @@
+import {
+  AutoBeAssistantMessageHistory,
+  AutoBeOpenApi,
+  AutoBeRealizeHistory,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { orchestrateRealizeCoder } from "./orchestrateRealizeCoder";
+import { orchestrateRealizePlanner } from "./orchestrateRealizePlanner";
+import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
+
+export const orchestrateRealize =
+  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
+  async (
+    props: IAutoBeApplicationProps,
+  ): Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory> => {
+    props;
+    const ops = ctx.state().interface?.document.operations;
+    if (!ops) {
+      throw new Error();
+    }
+
+    const files: Record<string, string> = {
+      ...ctx.state().interface?.files,
+      ...ctx.state().test?.files.reduce(
+        (acc, file) => {
+          acc[file.location] = file.content;
+          return acc;
+        },
+        {} as Record<string, string>,
+      ),
+    };
+
+    const codes: IAutoBeRealizeCoderApplication.IPipeOutput[] =
+      await Promise.all(
+        ops.map(async (op) => ({
+          operation: op,
+          result: await pipe(
+            op,
+            (op) => orchestrateRealizePlanner(ctx, op),
+            (p) => orchestrateRealizeCoder(ctx, op, p, files),
+          ),
+        })),
+      );
+
+    const successes: Array<{
+      operation: AutoBeOpenApi.IOperation;
+      result: IAutoBeRealizeCoderApplication.RealizeCoderOutput;
+    }> = [];
+    const failures: Array<{
+      operation: AutoBeOpenApi.IOperation;
+      result: FAILED;
+    }> = [];
+
+    for (const code of codes) {
+      if (code.result === FAILED) {
+        failures.push({
+          operation: code.operation,
+          result: code.result,
+        });
+      } else {
+        successes.push({
+          operation: code.operation,
+          result: code.result,
+        });
+      }
+    }
+
+    const now = new Date().toISOString();
+    ctx.dispatch({
+      type: "assistantMessage",
+      text: "Any codes can not be generated.",
+      created_at: now,
+    });
+
+    return {
+      type: "realize",
+      compiled: 1 as any,
+      files: {},
+      completed_at: now,
+      created_at: now,
+      id: v4(),
+      reason: props.reason,
+      step: ctx.state().test?.step ?? 0,
+    };
+  };
+
+export const FAILED = Symbol("FAILED");
+export type FAILED = typeof FAILED;
+
+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>(
+  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: 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

@@ -0,0 +1,148 @@
+import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { AutoBeOpenApi } 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 { enforceToolCall } from "../../utils/enforceToolCall";
+import { getTestScenarioArtifacts } from "../test/compile/getTestScenarioArtifacts";
+import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
+import { FAILED } from "./orchestrateRealize";
+import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
+import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
+import { transformRealizeCoderHistories } from "./transformRealizeCoderHistories";
+
+/**
+ * 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,
+  props: RealizePlannerOutput,
+  files: Record<string, string>,
+): Promise<IAutoBeRealizeCoderApplication.RealizeCoderOutput | FAILED> => {
+  const artifacts: IAutoBeTestScenarioArtifacts =
+    await getTestScenarioArtifacts(ctx, {
+      endpoint: {
+        method: operation.method,
+        path: operation.path,
+      },
+      dependencies: [],
+    });
+
+  const pointer: IPointer<Pick<
+    IAutoBeRealizeCoderApplication.RealizeCoderOutput,
+    "implementationCode"
+  > | null> = {
+    value: null,
+  };
+
+  const controller = createApplication({
+    model: ctx.model,
+    build: (props) => {
+      pointer.value = props.result;
+    },
+  });
+
+  const agent = new MicroAgentica({
+    controllers: [controller],
+    model: ctx.model,
+    vendor: ctx.vendor,
+    config: {
+      ...ctx.config,
+      executor: {
+        describe: null,
+      },
+    },
+    histories: transformRealizeCoderHistories(ctx.state(), props, artifacts),
+  });
+  enforceToolCall(agent);
+
+  await agent.conversate("Write code.");
+  const tokenUsage = agent.getTokenUsage();
+  ctx.usage().record(tokenUsage, ["realize"]);
+
+  if (pointer.value === null) {
+    return FAILED;
+  }
+
+  pointer.value.implementationCode = await ctx.compiler.typescript.beautify(
+    pointer.value.implementationCode,
+  );
+  pointer.value.implementationCode = pointer.value.implementationCode
+    .replaceAll('import { MyGlobal } from "../MyGlobal";', "")
+    .replaceAll('import typia, { tags } from "typia";', "")
+    .replaceAll('import { Prisma } from "@prisma/client";', "")
+    .replaceAll('import { jwtDecode } from "./jwtDecode"', "");
+  pointer.value.implementationCode = [
+    'import { MyGlobal } from "../MyGlobal";',
+    'import typia, { tags } from "typia";',
+    'import { Prisma } from "@prisma/client";',
+    'import { jwtDecode } from "./jwtDecode"',
+    "",
+    pointer.value.implementationCode,
+  ].join("\n");
+
+  files[`src/providers/${props.functionName}.ts`] =
+    pointer.value.implementationCode;
+
+  return { ...pointer.value, functionName: 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: {
+      programing: (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/orchestrateRealizePlanner.ts

@@ -0,0 +1,115 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+
+export interface RealizePlannerOutput {
+  /**
+   * The name of the function to be generated.
+   *
+   * Derived from the Swagger path and method. The function name must be written
+   * in snake_case. It serves as the entry point in both code generation and
+   * test code.
+   *
+   * Once the function is generated, the function name and file name will be the
+   * same. The generated file will be located at
+   * `src/providers/${function_name}.ts`.
+   */
+  functionName: string;
+
+  /**
+   * Definition of path and query parameters extracted from the OpenAPI spec.
+   *
+   * Includes input values passed via URL path or query string. Used for type
+   * definitions, validation, and function signature construction.
+   */
+  parameters: AutoBeOpenApi.IParameter[];
+
+  /**
+   * Schema definition for the request body input.
+   *
+   * Extracted from the requestBody section of Swagger. Represents the input
+   * data passed in the body (e.g., JSON). Used for generating function
+   * arguments or DTOs.
+   */
+  inputSchema: AutoBeOpenApi.IRequestBody | null;
+
+  /**
+   * Schema definition for the response body.
+   *
+   * Extracted from the responses section of Swagger. Used to define the return
+   * type and expected output in test code.
+   */
+  outputSchema: AutoBeOpenApi.IResponseBody | null;
+
+  /**
+   * Natural language description of the function’s purpose.
+   *
+   * Extracted from the summary or description field of Swagger. Used for code
+   * documentation, test scenario generation, and conveying function intent.
+   */
+  description: string;
+
+  /**
+   * HTTP method information.
+   *
+   * Extracted from the Swagger operation method. Used to define the request
+   * type during code and test generation.
+   */
+  operationType: "get" | "post" | "put" | "delete" | "patch";
+
+  /**
+   * List of scenario descriptions for test code generation.
+   *
+   * Each scenario describes the expected behavior of the function under certain
+   * conditions. Used as a basis for TDD-style automated test generation.
+   */
+  testScenarios: string[];
+}
+
+/**
+ * Generates a planning result that defines what kind of function should be
+ * created, based solely on the provided Swagger (OpenAPI) operation — without
+ * using an LLM.
+ *
+ * This function analyzes the structure of the OpenAPI operation (such as the
+ * path, method, parameters, request/response schema, and descriptions) to
+ * determine the appropriate function name, input/output types, and purpose of
+ * the function.
+ *
+ * The result of this function (`RealizePlannerOutput`) will be passed to the
+ * next step in the AutoBE pipeline, which is responsible for generating the
+ * actual implementation code.
+ *
+ * @param ctx - AutoBE context including model and configuration
+ * @param operation - A single OpenAPI operation object to analyze and plan
+ * @returns A planning object containing all structural information needed to
+ *   generate the function
+ */
+export const orchestrateRealizePlanner = async <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  operation: AutoBeOpenApi.IOperation,
+): Promise<RealizePlannerOutput> => {
+  const testScenarios =
+    ctx
+      .state()
+      .test?.files.filter(
+        (el) =>
+          el.scenario.endpoint.method === operation.method &&
+          el.scenario.endpoint.path === operation.path,
+      ) ?? [];
+
+  return {
+    description: operation.description,
+    parameters: operation.parameters,
+    inputSchema: operation.requestBody,
+    outputSchema: operation.responseBody,
+    operationType: operation.method,
+    testScenarios: testScenarios.map((el) => el.scenario.draft),
+    functionName: `${operation.method}_${operation.path
+      .replaceAll("/", "_")
+      .replaceAll("-", "_")
+      .replaceAll("{", "$")
+      .replaceAll("}", "")}`,
+  } satisfies RealizePlannerOutput;
+};

package/src/orchestrate/realize/structures/IAutoBeRealizeCoderApplication.ts

@@ -0,0 +1,46 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+import { FAILED } from "../orchestrateRealize";
+
+export interface IAutoBeRealizeCoderApplication {
+  programing: (next: IAutoBeRealizeCoderApplication.IProps) => void;
+}
+
+export namespace IAutoBeRealizeCoderApplication {
+  export interface IProps {
+    result: RealizeCoderOutput;
+  }
+
+  /**
+   * The result of the code generation step, representing a fully generated
+   * TypeScript function.
+   */
+  export interface RealizeCoderOutput {
+    /**
+     * The name of the function to be generated.
+     *
+     * This name will be used as the function's identifier and as the export
+     * name in the provider file.
+     */
+    functionName: string;
+
+    /**
+     * The raw TypeScript code string implementing the function.
+     *
+     * - The implementation must be valid TypeScript code.
+     * - It should focus solely on the logic of the function.
+     * - Import statements do **not** need to be included. They will be
+     *   automatically inserted by the system.
+     * - Any unused imports will be automatically removed by eslint.
+     * - Type annotations (e.g. for parameters and return types) should be omitted
+     *   if they can be inferred.
+     */
+    implementationCode: string;
+  }
+
+  export interface IPipeOutput {
+    result: RealizeCoderOutput | FAILED;
+
+    operation: AutoBeOpenApi.IOperation;
+  }
+}

package/src/orchestrate/realize/transformRealizeCoderHistories.ts

@@ -0,0 +1,136 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
+import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
+
+export const transformRealizeCoderHistories = (
+  state: AutoBeState,
+  props: RealizePlannerOutput,
+  artifacts: IAutoBeTestScenarioArtifacts,
+): 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.REALIZE_CODER,
+        "",
+        "# Prisma Schemas",
+        "```json",
+        JSON.stringify(state.prisma.schemas),
+        "```",
+        "",
+        // "# Prisma Types",
+        // "```json",
+        // JSON.stringify(state.prisma.compiled.nodeModules),
+        // "```",
+        "# SDK",
+        "",
+        "The following is the SDK for the API. Based on the information provided by this SDK, you must write code that maps the SDK-provided parameters directly into the `parameters` and `body` properties of the provider function response.",
+        "If there are no parameters, define `parameters` as `Record<string, never>`. Similarly, if there is no body, define `body` as `Record<string, never>`.",
+        "**Every function must be implemented to accept both `parameters` and `body`, without exception.**",
+        "If any required type information is referenced in the SDK, refer to the definitions in the DTO section.",
+        "",
+        "```json",
+        JSON.stringify(artifacts.sdk),
+        "```",
+        "",
+        "# DTO",
+        "if you want to import this files, write this: 'import { something } from '../api/structures/something';'",
+        "",
+        "```json",
+        JSON.stringify(artifacts.dto),
+        "```",
+        "# Document",
+        "```json",
+        JSON.stringify(artifacts.document),
+        "```",
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        "write code by following information of operation.",
+        "```json",
+        JSON.stringify(props),
+        "```",
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/test/compile/completeTestCode.ts

@@ -0,0 +1,35 @@
+import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
+
+export function completeTestCode(
+  artifacts: IAutoBeTestScenarioArtifacts,
+  code: string,
+): string {
+  const typeReferences: string[] = Array.from(
+    new Set(
+      Object.keys(artifacts.document.components.schemas).map(
+        (key) => key.split(".")[0]!,
+      ),
+    ),
+  );
+
+  code = code.replace(/^[ \t]*import\b[\s\S]*?;[ \t]*$/gm, "").trim();
+  code = code.replace(/^[ \t]*import\b[\s\S]*?;[ \t]*$/gm, "").trim();
+  code = code.replaceAll(
+    'string & Format<"uuid">',
+    'string & tags.Format<"uuid">',
+  );
+  code = [
+    `import { ArrayUtil, RandomGenerator, TestValidator } from "@nestia/e2e";`,
+    `import { IConnection } from "@nestia/fetcher";`,
+    `import typia, { tags } from "typia";`,
+    "",
+    `import api from "@ORGANIZATION/PROJECT-api";`,
+    ...typeReferences.map(
+      (ref) =>
+        `import type { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,
+    ),
+    "",
+    code,
+  ].join("\n");
+  return code;
+}

package/src/orchestrate/test/{filterTestFileName.ts → compile/filterTestFileName.ts}

@@ -3,7 +3,7 @@ export function filterTestFileName(key: string): boolean {
   else if (key.startsWith("src/") === true) return true;
   return (
     key.startsWith("test/") === true &&
-    key.startsWith("test/features/") === false &&
+    key.startsWith("test/features/") === true &&
     key.startsWith("test/benchmark/") === false
   );
 }

package/src/orchestrate/test/compile/getTestExternalDeclarations.ts

@@ -0,0 +1,24 @@
+import { IAutoBeTestCompiler } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { Singleton } from "tstl";
+
+import { AutoBeContext } from "../../../context/AutoBeContext";
+
+export function getTestExternalDeclarations<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+): Promise<Record<string, string>> {
+  return singleton.get(ctx.compiler.test);
+}
+
+const singleton = new Singleton(async (compiler: IAutoBeTestCompiler) => {
+  const records: Record<string, string> = await compiler.getExternal();
+  const external = (location: string): Record<string, string> => {
+    const content: string | undefined = records[location];
+    if (content === undefined) throw new Error(`File not found: ${location}`);
+    return { [location]: content };
+  };
+  return {
+    ...external("node_modules/@nestia/e2e/lib/TestValidator.d.ts"),
+    ...external("node_modules/@nestia/fetcher/lib/IConnection.d.ts"),
+  } satisfies Record<string, string>;
+});

package/src/orchestrate/test/{compileTestScenario.ts → compile/getTestScenarioArtifacts.ts}

@@ -1,12 +1,12 @@
 import { AutoBeOpenApi, AutoBeTestScenario } from "@autobe/interface";
 import { ILlmSchema, OpenApiTypeChecker } from "@samchon/openapi";
 
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeTestScenarioArtifacts } from "./structures/IAutoBeTestScenarioArtifacts";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
 
-export async function compileTestScenario<Model extends ILlmSchema.Model>(
+export async function getTestScenarioArtifacts<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  scenario: AutoBeTestScenario,
+  scenario: Pick<AutoBeTestScenario, "endpoint" | "dependencies">,
 ): Promise<IAutoBeTestScenarioArtifacts> {
   const document: AutoBeOpenApi.IDocument = filterDocument(
     scenario,
@@ -15,18 +15,26 @@ export async function compileTestScenario<Model extends ILlmSchema.Model>(
   const entries: [string, string][] = Object.entries(
     await ctx.compiler.interface.compile(document),
   );
-  const filter = (prefix: string) =>
-    Object.fromEntries(entries.filter(([key]) => key.startsWith(prefix)));
+  const filter = (prefix: string, exclude?: string) => {
+    const result: [string, string][] = entries.filter(
+      ([key]) => key.startsWith(prefix) === true,
+    );
+    return Object.fromEntries(
+      exclude
+        ? result.filter(([key]) => key.startsWith(exclude) === false)
+        : result,
+    );
+  };
   return {
     document,
-    sdk: filter("src/api/functional"),
+    sdk: filter("src/api", "src/api/structures"),
     dto: filter("src/api/structures"),
     e2e: filter("test/features"),
   };
 }
 
 function filterDocument(
-  scenario: AutoBeTestScenario,
+  scenario: Pick<AutoBeTestScenario, "endpoint" | "dependencies">,
   document: AutoBeOpenApi.IDocument,
 ): AutoBeOpenApi.IDocument {
   const operations: AutoBeOpenApi.IOperation[] = document.operations.filter(