@autobe/agent 0.20.0 → 0.22.0

package/src/orchestrate/interface/utils/JsonSchemaFactory.ts

@@ -0,0 +1,171 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeOpenApiTypeChecker, StringUtil } from "@autobe/utils";
+import typia, { tags } from "typia";
+
+export namespace JsonSchemaFactory {
+  export const presets = (
+    typeNames: Set<string>,
+  ): Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> => {
+    const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
+    for (const [key, value] of Object.entries(DEFAULT_SCHEMAS)) {
+      schemas[key] = value;
+      typeNames.delete(key);
+    }
+    for (const key of typeNames)
+      if (isPage(key)) {
+        const data: string = getPageName(key);
+        schemas[key] = page(data);
+        typeNames.delete(key);
+        typeNames.add(data);
+      }
+    return schemas;
+  };
+
+  export const authorize = (
+    schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
+  ): void => {
+    for (const [key, value] of Object.entries(schemas)) {
+      if (key.endsWith(".IAuthorized") === false) continue;
+      else if (AutoBeOpenApiTypeChecker.isObject(value) === false) continue;
+
+      const parent: AutoBeOpenApi.IJsonSchemaDescriptive | undefined =
+        schemas[key.substring(0, key.length - ".IAuthorized".length)];
+      if (parent === undefined) continue;
+      else if (AutoBeOpenApiTypeChecker.isObject(parent) === false) continue;
+
+      value.properties = {
+        ...parent.properties,
+        ...value.properties,
+      };
+      value.required = [...parent.required];
+      if (value.required.includes("id") === false) value.required.push("id");
+      if (value.required.includes("token") === false)
+        value.required.push("token");
+    }
+  };
+
+  export const page = (
+    key: string,
+  ): AutoBeOpenApi.IJsonSchemaDescriptive.IObject => ({
+    type: "object",
+    properties: {
+      pagination: {
+        $ref: "#/components/schemas/IPage.IPagination",
+        description: "Page information.",
+      },
+      data: {
+        type: "array",
+        items: {
+          $ref: `#/components/schemas/${key}`,
+        },
+        description: "List of records.",
+      },
+    },
+    required: ["pagination", "data"],
+    description: StringUtil.trim`
+      A page.
+  
+      Collection of records with pagination information.
+    `,
+  });
+
+  export const fix = (path: string, input: unknown): void => {
+    if (isRecord(input) === false || isRecord(input[path]) === false) return;
+
+    if (input[path].description) delete input[path].description;
+    if (input[path].required) delete input[path].required;
+
+    for (const key of Object.keys(input[path]))
+      if (DEFAULT_SCHEMAS[key] !== undefined)
+        input[path][key] = DEFAULT_SCHEMAS[key];
+      else if (isPage(key) === true) {
+        const data: string = key.substring("IPage".length);
+        input[path][key] = page(data);
+      }
+  };
+
+  export const isPage = (key: string): boolean =>
+    key.startsWith("IPage") === true &&
+    key.startsWith("IPage.") === false &&
+    key !== "IPage";
+
+  export const getPageName = (key: string): string =>
+    key.substring("IPage".length);
+
+  const isRecord = (input: unknown): input is Record<string, unknown> =>
+    typeof input === "object" && input !== null;
+}
+
+const DEFAULT_SCHEMAS = typia.assertEquals<
+  Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>
+>(
+  typia.json.schemas<[IPage.IPagination, IAuthorizationToken]>().components
+    ?.schemas,
+);
+
+namespace IPage {
+  /** Page information. */
+  export interface IPagination {
+    /** Current page number. */
+    current: number & tags.Type<"uint32">;
+
+    /** Limitation of records per a page. */
+    limit: number & tags.Type<"uint32">;
+
+    /** Total records in the database. */
+    records: number & tags.Type<"uint32">;
+
+    /**
+     * Total pages.
+     *
+     * Equal to {@link records} / {@link limit} with ceiling.
+     */
+    pages: number & tags.Type<"uint32">;
+  }
+}
+
+/**
+ * Authorization token response structure.
+ *
+ * This interface defines the structure of the authorization token response
+ * returned after successful user authentication. It contains both access and
+ * refresh tokens along with their expiration information.
+ *
+ * This token structure is automatically included in API schemas when the system
+ * detects authorization roles in the requirements analysis phase. It provides a
+ * standard format for JWT-based authentication across the generated backend
+ * applications.
+ */
+interface IAuthorizationToken {
+  /**
+   * JWT access token for authenticated requests.
+   *
+   * This token should be included in the Authorization header for subsequent
+   * authenticated API requests as `Bearer {token}`.
+   */
+  access: string;
+
+  /**
+   * Refresh token for obtaining new access tokens.
+   *
+   * This token can be used to request new access tokens when the current access
+   * token expires, extending the user's session.
+   */
+  refresh: string;
+
+  /**
+   * Access token expiration timestamp.
+   *
+   * ISO 8601 date-time string indicating when the access token will expire and
+   * can no longer be used for authentication.
+   */
+  expired_at: string & tags.Format<"date-time">;
+
+  /**
+   * Refresh token expiration timestamp.
+   *
+   * ISO 8601 date-time string indicating the latest time until which the
+   * refresh token can be used to obtain new access tokens.
+   */
+  refreshable_until: string & tags.Format<"date-time">;
+}

package/src/orchestrate/interface/utils/JsonSchemaNamingConvention.ts

@@ -0,0 +1,83 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { MapUtil } from "@autobe/utils";
+import { OpenApiTypeChecker } from "@samchon/openapi";
+
+export namespace JsonSchemaNamingConvention {
+  export const operations = (operations: AutoBeOpenApi.IOperation[]): void => {
+    const typeNames: Set<string> = new Set();
+    operate(typeNames, operations);
+  };
+
+  export const schemas = (
+    operations: AutoBeOpenApi.IOperation[],
+    ...componentSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>[]
+  ): void => {
+    const typeNames: Set<string> = new Set();
+    for (const schemas of componentSchemas)
+      for (const key of Object.keys(schemas)) typeNames.add(key);
+    const answer = operate(typeNames, operations);
+
+    for (const dict of componentSchemas)
+      for (const x of Object.keys(dict)) {
+        const y: string = answer(x);
+        if (x === y) continue;
+        dict[y] = dict[x]!;
+        delete dict[x];
+      }
+    for (const dict of componentSchemas)
+      for (const x of Object.values(dict)) {
+        OpenApiTypeChecker.visit({
+          components: { schemas: dict },
+          schema: x,
+          closure: (s) => {
+            if (OpenApiTypeChecker.isReference(s) === false) return;
+            s.$ref = `#/components/schemas/${answer(s.$ref.split("/").pop()!)}`;
+          },
+        });
+      }
+  };
+
+  const operate = (
+    typeNames: Set<string>,
+    operations: AutoBeOpenApi.IOperation[],
+  ): ((v: string) => string) => {
+    for (const op of operations) {
+      if (op.requestBody) typeNames.add(op.requestBody.typeName);
+      if (op.responseBody) typeNames.add(op.responseBody.typeName);
+    }
+    const answer = prepare(typeNames);
+    for (const op of operations) {
+      if (op.requestBody)
+        op.requestBody.typeName = answer(op.requestBody.typeName);
+      if (op.responseBody)
+        op.responseBody.typeName = answer(op.responseBody.typeName);
+    }
+    return answer;
+  };
+
+  const prepare = (typeNames: Set<string>): ((v: string) => string) => {
+    const similar: Map<string, string[]> = new Map();
+    const getKey = (v: string) => v.split(".")[0]!.toLowerCase();
+    const getValue = (v: string) => v.split(".")[0]!;
+    const emplace = (v: string) =>
+      MapUtil.take(similar, getKey(v), () => []).push(getValue(v));
+
+    for (const v of typeNames) emplace(v);
+
+    const solution: Map<string, string> = new Map();
+    for (const [key, values] of similar) {
+      if (values.length === 1) continue;
+      const winner: string = values.sort(
+        (a, b) => countCapitalLetters(b) - countCapitalLetters(a),
+      )[0]!;
+      solution.set(key, winner);
+    }
+    return (v: string) => {
+      const key: string = getKey(v);
+      if (solution.has(key) === false) return v;
+      return [solution.get(key), ...v.split(".").slice(1)].join(".");
+    };
+  };
+}
+
+const countCapitalLetters = (str: string) => (str.match(/[A-Z]/g) || []).length;

package/src/orchestrate/interface/utils/fulfillJsonSchemaErrorMessages.ts

@@ -0,0 +1,90 @@
+import { StringUtil } from "@autobe/utils";
+import { IValidation } from "typia";
+
+export const fulfillJsonSchemaErrorMessages = (
+  errors: IValidation.IError[],
+): void => {
+  for (const e of errors)
+    if (
+      // type := ["number", "string", ...] case
+      isInvalidJsonSchema(e) &&
+      typeof e.value === "object" &&
+      e.value !== null &&
+      "type" in e.value &&
+      Array.isArray(e.value.type)
+    )
+      e.description = StringUtil.trim`
+        You have defined the JSON schema's type property value as an 
+        array type listing up the every types what you want, but it is not 
+        allowed in the JSON schema.
+        
+        The JSON schema's type property value must be a single string type.
+        In your case, you have to change it to an "oneOf" type which 
+        represents an union type.
+
+        So, please change the value as below:
+
+        \`\`\`
+        {
+          oneOf: [
+        ${e.value.type.map((t) => `    { "type": ${JSON.stringify(t)}, ... },`).join("\n")}
+          ],${"description" in e.value ? `\n  description: ${JSON.stringify(e.value.description)},` : ""}
+        }
+        \`\`\`
+      `;
+    else if (
+      isInvalidJsonSchema(e) &&
+      typeof e.value === "object" &&
+      e.value !== null &&
+      "enum" in e.value &&
+      Array.isArray(e.value.enum)
+    )
+      e.description = StringUtil.trim`
+        You have defined only enum property, but it is not allowed in the 
+        JSON schema. You have to define it as oneOf type containing multiple
+        const types like below:
+        
+        \`\`\`
+        {
+          oneOf: [
+        ${e.value.enum.map((t) => `    { "const": ${JSON.stringify(t)} },`).join("\n")}
+          ],${"description" in e.value ? `\n  description: ${JSON.stringify(e.value.description)},` : ""}
+        }
+        \`\`\`
+      `;
+    else if (e.value === undefined && e.path.endsWith(".description"))
+      // no description
+      e.description = StringUtil.trim`
+        You have missed the "description" property in the JSON schema. 
+        
+        Please fill it with detailed description about the type.
+      `;
+    else if (
+      e.value === undefined &&
+      e.path.endsWith(".required") &&
+      e.expected === "Array<string>"
+    )
+      e.description = StringUtil.trim`
+        You have missed the "required" property in the JSON schema of object type.
+
+        When defining the object type, you have to fill the "required" property
+        which lists up the every required property names.
+
+        Please fill it with the required fields. If you think that there is
+        not any required fields at all, you still have to fill the 
+        "required" property even though it becomes an empty array.
+      `;
+};
+
+const isInvalidJsonSchema = (e: IValidation.IError): boolean =>
+  e.expected.startsWith("(") &&
+  e.expected.endsWith(")") &&
+  e.expected.includes("|") &&
+  e.expected
+    .split("|")
+    .map((s) => s.trim())
+    .every(
+      (s) =>
+        s.startsWith("AutoBeOpenApi.IJsonSchema.") ||
+        s.startsWith("AutoBeOpenApi.IJsonSchemaDescriptive."),
+    );

package/src/orchestrate/interface/utils/validateAuthorizationSchema.ts

@@ -25,7 +25,7 @@ export const validateAuthorizationSchema = (props: {
     value.properties["token"] = {
       $ref: "#/components/schemas/IAuthorizationToken",
       description: "JWT token information for authentication",
-    } as AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema.IReference>;
+    } as AutoBeOpenApi.IJsonSchemaDescriptive.IReference;
 
     value.required ??= [];
     if (value.required.includes("token") === false) {
@@ -36,6 +36,6 @@ export const validateAuthorizationSchema = (props: {
 
 const isObjectSchema = (
   schema: AutoBeOpenApi.IJsonSchemaDescriptive,
-): schema is AutoBeOpenApi.IJsonSchemaDescriptive<AutoBeOpenApi.IJsonSchema.IObject> => {
+): schema is AutoBeOpenApi.IJsonSchemaDescriptive.IObject => {
   return "type" in schema && schema.type === "object";
 };

package/src/orchestrate/prisma/orchestratePrismaCorrect.ts

@@ -18,7 +18,6 @@ import { IAutoBePrismaCorrectApplication } from "./structures/IAutoBePrismaCorre
 export function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   application: AutoBePrisma.IApplication,
-  life: number = 4,
 ): Promise<IAutoBePrismaValidation> {
   const unique: Set<string> = new Set();
   for (const file of application.files)
@@ -28,7 +27,7 @@ export function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(
       return true;
     });
   application.files = application.files.filter((f) => f.models.length !== 0);
-  return iterate(ctx, application, life);
+  return iterate(ctx, application, ctx.retry);
 }
 
 async function iterate<Model extends ILlmSchema.Model>(

package/src/orchestrate/realize/histories/transformRealizeCorrectHistories.ts

@@ -1,25 +1,22 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import {
-  AutoBeRealizeAuthorization,
-  IAutoBeTypeScriptCompileResult,
-} from "@autobe/interface";
+import { AutoBeRealizeAuthorization } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
-import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
-import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
+import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
 import { transformRealizeWriteHistories } from "./transformRealizeWriteHistories";
 
 export function transformRealizeCorrectHistories(props: {
   state: AutoBeState;
-  scenario: IAutoBeRealizeScenarioApplication.IProps;
-  artifacts: IAutoBeTestScenarioArtifacts;
+  scenario: IAutoBeRealizeScenarioResult;
   authorization: AutoBeRealizeAuthorization | null;
   totalAuthorizations: AutoBeRealizeAuthorization[];
   code: string;
-  diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+  dto: Record<string, string>;
+  failures: IAutoBeRealizeFunctionFailure[];
 }): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > {
@@ -34,15 +31,33 @@ export function transformRealizeCorrectHistories(props: {
         \`\`\`typescript
         ${props.code}
         \`\`\`
-
-        The code has a compilation error:
-        
-        \`\`\`json
-        ${JSON.stringify(props.diagnostic)}
-        \`\`\`
       `,
       created_at: new Date().toISOString(),
     },
+    ...props.failures.map(
+      (f) =>
+        ({
+          id: v7(),
+          type: "assistantMessage",
+          text: StringUtil.trim`
+
+      ## Generated Typescript Code
+
+      \`\`\`typescript
+      ${f.function.content}
+      \`\`\`
+
+      ## Compile Errors
+
+      Fix the comilation error in the provided code.
+
+      \`\`\`typescript
+      ${JSON.stringify(f.diagnostics)}
+      \`\`\`
+      `,
+          created_at: new Date().toISOString(),
+        }) satisfies IAgenticaHistoryJson.IAssistantMessage,
+    ),
     {
       id: v7(),
       type: "systemMessage",

package/src/orchestrate/realize/histories/transformRealizeWriteHistories.ts

@@ -5,13 +5,18 @@ import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
-import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
-import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
+import { getRealizeWriteCodeTemplate } from "../utils/getRealizeWriteCodeTemplate";
+import { getRealizeWriteInputType } from "../utils/getRealizeWriteInputType";
 import { transformRealizeWriteAuthorizationsHistories } from "./transformRealizeWriteAuthorizationsHistories";
 
-export const transformRealizeWriteHistories = (
-  props: IProps,
-): Array<
+export const transformRealizeWriteHistories = (props: {
+  state: AutoBeState;
+  scenario: IAutoBeRealizeScenarioResult;
+  authorization: AutoBeRealizeAuthorization | null;
+  totalAuthorizations: AutoBeRealizeAuthorization[];
+  dto: Record<string, string>;
+}): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
   const payloads = Object.fromEntries(
@@ -21,38 +26,7 @@ export const transformRealizeWriteHistories = (
     ]),
   );
 
-  const [operation] = props.artifacts.document.operations;
-
-  const propsFields: string[] = [];
-
-  // payload 추가
-  if (props.authorization && operation.authorizationRole) {
-    propsFields.push(
-      `${operation.authorizationRole}: ${props.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
-      ? StringUtil.trim`
-        props: {
-        ${propsFields.map((field) => `  ${field},`).join("\n")}
-        }`
-      : `// No props parameter needed - function should have no parameters`;
+  const operation = props.scenario.operation;
 
   if (props.state.analyze === null)
     return [
@@ -132,7 +106,7 @@ export const transformRealizeWriteHistories = (
       id: v7(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
-      text: AutoBeSystemPromptConstant.REALIZE_WRITE_TOTAL,
+      text: AutoBeSystemPromptConstant.REALIZE_WRITE,
     },
     ...authorizationHistories,
     {
@@ -143,14 +117,26 @@ export const transformRealizeWriteHistories = (
         `{prisma_schemas}`,
         JSON.stringify(props.state.prisma.schemas),
       )
-        .replaceAll(`{artifacts_sdk}`, JSON.stringify(props.artifacts.sdk))
-        .replaceAll(`{artifacts_dto}`, JSON.stringify(props.artifacts.dto))
-        .replaceAll(`{input}`, input),
+        .replaceAll(
+          `{input}`,
+          getRealizeWriteInputType(operation, props.authorization),
+        )
+        .replaceAll(`{artifacts_dto}`, JSON.stringify(props.dto)),
     },
     {
       id: v7(),
+      type: "systemMessage",
       created_at: new Date().toISOString(),
+      text: getRealizeWriteCodeTemplate(
+        props.scenario,
+        operation,
+        props.authorization,
+      ),
+    },
+    {
+      id: v7(),
       type: "systemMessage",
+      created_at: new Date().toISOString(),
       text: StringUtil.trim`
         Write new code based on the following operation.
         
@@ -179,11 +165,3 @@ export const transformRealizeWriteHistories = (
     },
   ];
 };
-
-interface IProps {
-  state: AutoBeState;
-  scenario: IAutoBeRealizeScenarioApplication.IProps;
-  artifacts: IAutoBeTestScenarioArtifacts;
-  authorization: AutoBeRealizeAuthorization | null;
-  totalAuthorizations: AutoBeRealizeAuthorization[];
-}

package/src/orchestrate/realize/internal/compileRealizeFiles.ts

@@ -16,7 +16,7 @@ export async function compileRealizeFiles<Model extends ILlmSchema.Model>(
     authorizations: AutoBeRealizeAuthorization[];
     functions: AutoBeRealizeFunction[];
   },
-): Promise<IAutoBeTypeScriptCompileResult> {
+): Promise<AutoBeRealizeValidateEvent> {
   const prisma = ctx.state().prisma?.compiled;
   const payloads: Record<string, string> = Object.fromEntries(
     props.authorizations.map((el) => [el.payload.location, el.payload.content]),
@@ -50,22 +50,15 @@ export async function compileRealizeFiles<Model extends ILlmSchema.Model>(
     await compiler.typescript.compile({
       files: files,
     });
-  if (compiled.type === "success") {
-    return compiled;
-  }
 
   const event: AutoBeRealizeValidateEvent = {
     type: "realizeValidate",
     id: v7(),
+    files: files,
     result: compiled,
-    files: Object.fromEntries(
-      compiled.type === "failure"
-        ? compiled.diagnostics.map((d) => [d.file, d.code])
-        : [],
-    ),
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   };
-  ctx.dispatch(event);
-  return compiled;
+
+  return event;
 }