@autobe/agent 0.28.1 → 0.29.1

package/src/orchestrate/realize/orchestrateRealizeAuthorization.ts

@@ -1,185 +0,0 @@
-import { IAgenticaController } from "@agentica/core";
-import {
-  AutoBeAnalyzeActor,
-  AutoBeProgressEventBase,
-  AutoBeRealizeAuthorization,
-  AutoBeRealizeAuthorizationWriteEvent,
-  IAutoBeCompiler,
-} from "@autobe/interface";
-import { ILlmApplication, ILlmSchema } 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 { transformRealizeAuthorizationHistories } from "./histories/transformRealizeAuthorization";
-import { orchestrateRealizeAuthorizationCorrect } from "./orchestrateRealizeAuthorizationCorrect";
-import { IAutoBeRealizeAuthorizationApplication } from "./structures/IAutoBeRealizeAuthorizationApplication";
-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 orchestrateRealizeAuthorization<
-  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 templateFiles = await (
-    await ctx.compiler()
-  ).realize.getTemplate({
-    dbms: "sqlite",
-  });
-  const authorizations: AutoBeRealizeAuthorization[] = await executeCachedBatch(
-    actors.map(
-      (a) => (promptCacheKey) =>
-        process(
-          ctx,
-          a,
-          InternalFileSystem.DEFAULT.map((el) => ({
-            [el]: templateFiles[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>,
-  actor: AutoBeAnalyzeActor,
-  templateFiles: Record<string, string>,
-  progress: AutoBeProgressEventBase,
-  promptCacheKey: string,
-): Promise<AutoBeRealizeAuthorization> {
-  const pointer: IPointer<IAutoBeRealizeAuthorizationApplication.IProps | null> =
-    {
-      value: null,
-    };
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "realizeAuthorizationWrite",
-    histories: transformRealizeAuthorizationHistories(ctx, actor),
-    controller: createController({
-      model: ctx.model,
-      build: (next) => {
-        pointer.value = next;
-      },
-    }),
-    enforceFunctionCall: true,
-    promptCacheKey,
-    message: "Create Authorization Provider and Decorator.",
-  });
-  if (pointer.value === null) throw new Error("Failed to create decorator.");
-
-  const compiler: IAutoBeCompiler = await ctx.compiler();
-  const authorization: AutoBeRealizeAuthorization = {
-    actor: 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,
-    },
-  };
-  const compiled = ctx.state().prisma?.compiled;
-  const prismaClients: Record<string, string> =
-    compiled?.type === "success" ? compiled.nodeModules : {};
-
-  ctx.dispatch({
-    type: "realizeAuthorizationWrite",
-    id: v7(),
-    created_at: new Date().toISOString(),
-    authorization: authorization,
-    metric,
-    tokenUsage,
-    completed: ++progress.completed,
-    total: progress.total,
-    step: ctx.state().test?.step ?? 0,
-  } satisfies AutoBeRealizeAuthorizationWriteEvent);
-  return orchestrateRealizeAuthorizationCorrect(
-    ctx,
-    authorization,
-    prismaClients,
-    templateFiles,
-  );
-}
-
-function createController<Model extends ILlmSchema.Model>(props: {
-  model: Model;
-  build: (next: IAutoBeRealizeAuthorizationApplication.IProps) => void;
-}): IAgenticaController.IClass<Model> {
-  assertSchemaModel(props.model);
-
-  const application: ILlmApplication<Model> = collection[
-    props.model === "chatgpt"
-      ? "chatgpt"
-      : props.model === "gemini"
-        ? "gemini"
-        : "claude"
-  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
-
-  return {
-    protocol: "class",
-    name: "Create Decorator",
-    application,
-    execute: {
-      createDecorator: (next) => {
-        props.build(next);
-      },
-    } satisfies IAutoBeRealizeAuthorizationApplication,
-  };
-}
-
-const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeRealizeAuthorizationApplication,
-    "chatgpt"
-  >(),
-  claude: typia.llm.application<
-    IAutoBeRealizeAuthorizationApplication,
-    "claude"
-  >(),
-  gemini: typia.llm.application<
-    IAutoBeRealizeAuthorizationApplication,
-    "gemini"
-  >(),
-};

package/src/orchestrate/test/histories/transformTestCorrectInvalidRequestHistories.ts

@@ -1,39 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
-import { v7 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
-import { IAutoBeTestFunction } from "../structures/IAutoBeTestFunction";
-
-export const transformTestCorrectInvalidRequestHistories = (
-  func: IAutoBeTestFunction,
-  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
-): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => [
-  {
-    id: v7(),
-    created_at: new Date().toISOString(),
-    type: "systemMessage",
-    text: AutoBeSystemPromptConstant.TEST_CORRECT_INVALID_REQUEST,
-  },
-  {
-    id: v7(),
-    created_at: new Date().toISOString(),
-    type: "assistantMessage",
-    text: StringUtil.trim`
-      ## TypeScript Code
-      
-      \`\`\`typescript
-      ${func.script}
-      \`\`\`
-
-      ## Compile Errors
-
-      \`\`\`json
-      ${JSON.stringify(diagnostics)}
-      \`\`\`
-    `,
-  },
-];

package/src/orchestrate/test/histories/transformTestScenarioHistories.ts

@@ -1,125 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeInterfaceAuthorization, AutoBeOpenApi } from "@autobe/interface";
-import { MapUtil, StringUtil } from "@autobe/utils";
-import { v7 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../../context/AutoBeState";
-import { IAutoBeTestScenarioAuthorizationActor } from "../structures/IAutoBeTestScenarioAuthorizationActor";
-import { getPrerequisites } from "../utils/getPrerequisites";
-
-export const transformTestScenarioHistories = (props: {
-  state: AutoBeState;
-  document: AutoBeOpenApi.IDocument;
-  include: AutoBeOpenApi.IOperation[];
-  exclude: Pick<AutoBeOpenApi.IOperation, "method" | "path">[];
-  instruction: string;
-}): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => {
-  const authorizations: AutoBeInterfaceAuthorization[] =
-    props.state.interface?.authorizations ?? [];
-  const authorizationActors: Map<
-    string,
-    IAutoBeTestScenarioAuthorizationActor
-  > = new Map();
-
-  for (const authorization of authorizations) {
-    for (const op of authorization.operations) {
-      if (op.authorizationType === null) continue;
-      const value: IAutoBeTestScenarioAuthorizationActor = MapUtil.take(
-        authorizationActors,
-        authorization.name,
-        () => ({
-          name: authorization.name,
-          join: null,
-          login: null,
-        }),
-      );
-      if (op.authorizationType === "join") value.join = op;
-      else if (op.authorizationType === "login") value.login = op;
-    }
-  }
-
-  return [
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.TEST_SCENARIO,
-    } satisfies IAgenticaHistoryJson.ISystemMessage,
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
-        ## Instructions
-
-        The following e2e-test-specific instructions were extracted from
-        the user's requirements and conversations. These instructions focus
-        exclusively on test-related aspects such as test coverage priorities,
-        specific edge cases to validate, business logic verification strategies,
-        and critical user workflows that must be tested.
-        
-        Follow these instructions when generating test scenarios.
-        Carefully distinguish between:
-        - Suggestions or recommendations (consider these as guidance)
-        - Direct specifications or explicit commands (these must be followed exactly)
-        
-        When instructions contain direct specifications or explicit design decisions, 
-        follow them precisely even if you believe you have better alternatives.
-
-        ${props.instruction}
-
-        ## API Operations
-
-        Below are the complete API operations.
-        Use this information to understand capabilities and dependency relationships.
-        Generate scenarios only for endpoints listed in "Included in Test Plan".
-        Other operations may be referenced as dependencies only.
-
-        You may write multiple scenarios for a single included endpoint.
-        Focus on business-logic-oriented E2E flows rather than trivial CRUD.
-
-        \`\`\`json
-        ${JSON.stringify({
-          operations: props.document.operations,
-        })}
-        \`\`\`
-
-        ## Included in Test Plan
-
-        Below are the endpoints that have been included in the test plan.
-        Each endpoint shows its authentication requirements and related authentication APIs.
-        When testing endpoints that require authentication, ensure you include the corresponding 
-        join/login operations in your test scenario to establish proper authentication context.
-
-        \`\`\`json
-        ${JSON.stringify(
-          props.include.map((el) => ({
-            ...el,
-            prerequisites: getPrerequisites({
-              document: props.document,
-              endpoint: el,
-            }),
-            authorizationActors: Array.from(
-              authorizationActors.values(),
-            ).filter((actor) => actor.name === el.authorizationActor),
-          })),
-        )}
-        \`\`\`
-
-        ## Excluded from Test Plan
-
-        These are the endpoints that have already been used in test codes generated as part of a plan group.
-        These endpoints do not need to be tested again.
-        However, it is allowed to reference or depend on these endpoints when writing test codes for other purposes.
-
-        \`\`\`json
-        ${JSON.stringify(props.exclude)}
-        \`\`\`
-
-      `,
-    } satisfies IAgenticaHistoryJson.IAssistantMessage,
-  ];
-};

package/src/orchestrate/test/histories/transformTestScenarioReviewHistories.ts

@@ -1,89 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeOpenApi } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
-import { v7 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../../context/AutoBeState";
-import { IAutoBeTestScenarioApplication } from "../structures/IAutoBeTestScenarioApplication";
-import { getPrerequisites } from "../utils/getPrerequisites";
-
-export function transformTestScenarioReviewHistories(props: {
-  state: AutoBeState;
-  instruction: string;
-  groups: IAutoBeTestScenarioApplication.IScenarioGroup[];
-}): Array<
-  IAgenticaHistoryJson.ISystemMessage | IAgenticaHistoryJson.IAssistantMessage
-> {
-  const document: AutoBeOpenApi.IDocument | undefined =
-    props.state.interface?.document;
-  if (document === undefined) {
-    throw new Error(
-      "Cannot review test scenarios because there are no operations.",
-    );
-  }
-
-  return [
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.TEST_SCENARIO,
-    },
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.TEST_SCENARIO_REVIEW,
-    },
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
-        ## Instructions
-
-        The following e2e-test-specific instructions were extracted from
-        the user's requirements and conversations. These instructions focus
-        exclusively on test-related aspects such as test coverage priorities,
-        specific edge cases to validate, business logic verification strategies,
-        and critical user workflows that must be tested.
-        
-        Follow these instructions when reviewing test scenarios.
-        Carefully distinguish between:
-        - Suggestions or recommendations (consider these as guidance)
-        - Direct specifications or explicit commands (these must be followed exactly)
-        
-        When instructions contain direct specifications or explicit design decisions, 
-        follow them precisely even if you believe you have better alternatives.
-
-        ${props.instruction}
-
-        ## Available API Operations for Reference
-
-        Below are all available API operations and interface schemas for validation purposes.
-        Match each operation with its corresponding schema.
-
-        \`\`\`json
-        ${JSON.stringify({ operations: document.operations })}
-        \`\`\`
-
-        ## Test Scenario Groups to Review
-
-        Each scenario group includes the target endpoint and its prerequisite endpoints.
-
-        \`\`\`json
-        ${JSON.stringify(
-          props.groups.map((g) => ({
-            ...g,
-            prerequisites: getPrerequisites({
-              document,
-              endpoint: g.endpoint,
-            }),
-          })),
-        )}
-        \`\`\`
-      `,
-    },
-  ];
-}

package/src/orchestrate/test/histories/transformTestWriteHistories.ts

@@ -1,172 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeTestScenario } from "@autobe/interface";
-import { StringUtil, transformOpenApiDocument } from "@autobe/utils";
-import {
-  HttpMigration,
-  IHttpMigrateApplication,
-  ILlmSchema,
-  OpenApi,
-} from "@samchon/openapi";
-import { Singleton } from "tstl";
-import typia from "typia";
-import { v7 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
-import { AutoBeContext } from "../../../context/AutoBeContext";
-import { getTestExternalDeclarations } from "../compile/getTestExternalDeclarations";
-import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
-
-export async function transformTestWriteHistories<
-  Model extends ILlmSchema.Model,
->(
-  ctx: AutoBeContext<Model>,
-  props: {
-    instruction: string;
-    scenario: AutoBeTestScenario;
-    artifacts: IAutoBeTestScenarioArtifacts;
-  },
-): Promise<
-  Array<
-    IAgenticaHistoryJson.ISystemMessage | IAgenticaHistoryJson.IAssistantMessage
-  >
-> {
-  return [
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: systemPrompt.get(),
-    },
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
-        Here is the list of input material composition.
-
-        Make e2e test functions based on the following information.
-
-        ## Instructions
-
-        The following e2e-test-specific instructions were extracted from
-        the user's requirements and conversations. These instructions focus
-        exclusively on test-related aspects such as test data generation strategies,
-        assertion patterns, error handling approaches, and specific validation logic
-        that should be implemented in the test code.
-        
-        Follow these instructions when implementing the e2e test function.
-        Carefully distinguish between:
-        - Suggestions or recommendations (consider these as guidance)
-        - Direct specifications or explicit commands (these must be followed exactly)
-        
-        When instructions contain direct specifications or explicit design decisions, 
-        follow them precisely even if you believe you have better alternatives.
-
-        ${props.instruction}
-
-        ## Function Name
-
-        The e2e test function name must be ${JSON.stringify(props.scenario.functionName)}.
-
-        ## Scenario Plan
-
-        Here is the scenario plan what you have to implement.
-
-        \`\`\`json
-        ${JSON.stringify(props.scenario)}
-        \`\`\`
-
-        ## DTO Definitions
-
-        You can use these DTO definitions.
-
-        Never use the DTO definitions that are not listed here.
-
-        ${transformTestWriteHistories.structures(props.artifacts)}
-
-        ## API (SDK) Functions
-
-        You can use these API functions.
-
-        Never use the functions that are not listed here.
-
-        ${transformTestWriteHistories.functional(props.artifacts)}
-
-        ## E2E Mockup Functions
-
-        Just reference, and never follow this code as it is.
-
-        \`\`\`json
-        ${JSON.stringify(props.artifacts.e2e)}
-        \`\`\`
-
-        ## External Definitions
-
-        Here is the external declaration files (d.ts) you can reference.
-
-        \`\`\`json
-        ${JSON.stringify(await getTestExternalDeclarations(ctx))}
-        \`\`\`
-
-        ## Template Code
-
-        Here is the template e2e test code what you must follow.
-
-        You're only allowed to modify the "<SCENARIO DESCRIPTION HERE>" and
-        code inside the function block marked as "// <E2E TEST CODE HERE>". 
-        Change the template code by writing your scenario description to the 
-        comment, and filling your implementation logic into the function.
-
-        Note that, you don't need to add any "import" statement more than
-        this template code. Everything you need is already imported, so
-        make your implementation code in the import scope.
-
-        \`\`\`typescript
-        ${props.artifacts.template}
-        \`\`\`
-      `,
-    },
-  ];
-}
-export namespace transformTestWriteHistories {
-  export function structures(artifacts: IAutoBeTestScenarioArtifacts): string {
-    return StringUtil.trim`
-      ${Object.keys(artifacts.document.components.schemas)
-        .map((k) => `- ${k}`)
-        .join("\n")}
-
-      \`\`\`json
-      ${JSON.stringify(artifacts.dto)}
-      \`\`\`
-    `;
-  }
-
-  export function functional(artifacts: IAutoBeTestScenarioArtifacts): string {
-    const document: OpenApi.IDocument = transformOpenApiDocument(
-      artifacts.document,
-    );
-    const app: IHttpMigrateApplication = HttpMigration.application(document);
-    return StringUtil.trim`
-      Method | Path | Function Accessor
-      -------|------|-------------------
-      ${app.routes
-        .map((r) =>
-          [r.method, r.path, `api.functional.${r.accessor.join(".")}`].join(
-            " | ",
-          ),
-        )
-        .join("\n")}
-
-      \`\`\`json
-      ${JSON.stringify(artifacts.sdk)}
-      \`\`\`
-    `;
-  }
-}
-
-const systemPrompt = new Singleton(() =>
-  AutoBeSystemPromptConstant.TEST_WRITE.replace(
-    "{{AutoBeTestScenario}}",
-    JSON.stringify(typia.llm.parameters<AutoBeTestScenario, "claude">()),
-  ),
-);

package/src/utils/TokenUsageComputer.ts

@@ -1,35 +0,0 @@
-import { IAutoBeTokenUsageJson } from "@autobe/interface";
-
-export namespace TokenUsageComputer {
-  export const plus = (
-    x: IAutoBeTokenUsageJson.IComponent,
-    y: IAutoBeTokenUsageJson.IComponent,
-  ): IAutoBeTokenUsageJson.IComponent => ({
-    total: x.total + y.total,
-    input: {
-      total: x.input.total + y.input.total,
-      cached: x.input.cached + y.input.cached,
-    },
-    output: {
-      total: x.output.total + y.output.total,
-      reasoning: x.output.reasoning + y.output.reasoning,
-      accepted_prediction:
-        x.output.accepted_prediction + y.output.accepted_prediction,
-      rejected_prediction:
-        x.output.rejected_prediction + y.output.rejected_prediction,
-    },
-  });
-
-  export const increment = (
-    x: IAutoBeTokenUsageJson.IComponent,
-    y: IAutoBeTokenUsageJson.IComponent,
-  ): void => {
-    x.total += y.total;
-    x.input.total += y.input.total;
-    x.input.cached += y.input.cached;
-    x.output.total += y.output.total;
-    x.output.reasoning += y.output.reasoning;
-    x.output.accepted_prediction += y.output.accepted_prediction;
-    x.output.rejected_prediction += y.output.rejected_prediction;
-  };
-}