@autobe/agent 0.24.2 → 0.25.1

package/src/orchestrate/realize/utils/replaceImportStatements.ts

@@ -4,119 +4,121 @@ import { ILlmSchema } from "@samchon/openapi";
 import { AutoBeContext } from "../../../context/AutoBeContext";
 import { getRealizeWriteImportStatements } from "./getRealizeWriteImportStatements";
 
-/**
- * Removes all import statements that LLM might have incorrectly added. This
- * includes standard library imports, auto-injected imports, and any API
- * structure imports with wrong paths.
- *
- * @param code - The code containing imports to remove
- * @param typeReferences - List of type names to specifically remove
- * @param decoratorType - Optional decorator type to remove
- * @returns Code with all imports removed
- */
-function removeAllImports(
-  code: string,
-  typeReferences: string[],
-  decoratorType?: string,
-): string {
-  // Remove standard library and auto-injected imports
-  let cleanedCode = code
-    // MyGlobal - often with wrong path
-    .replace(
-      /import\s*{\s*MyGlobal\s*}\s*from\s*["']\.\.\/MyGlobal["']\s*;?\s*/gm,
-      "",
-    )
-    // typia - various import patterns
-    .replace(
-      /import\s+typia\s*,\s*{\s*tags\s*}\s*from\s*["']typia["']\s*;?\s*/gm,
-      "",
-    )
-    .replace(/import\s*{\s*tags\s*}\s*from\s*["']typia["']\s*;?\s*/gm, "")
-    .replace(
-      /import\s*{\s*tags\s*,\s*typia\s*}\s*from\s*["']typia["']\s*;?\s*/gm,
-      "",
-    )
-    .replace(/import\s+typia\s*from\s*["']typia["']\s*;?\s*/gm, "")
-    // Prisma client
-    .replace(
-      /import\s*{\s*Prisma\s*}\s*from\s*["']@prisma\/client["']\s*;?\s*/gm,
-      "",
-    )
-    // uuid
-    .replace(/import\s*{\s*v4\s*}\s*from\s*["']uuid["']\s*;?\s*/gm, "")
-    // toISOStringSafe utility
-    .replace(
-      /import\s*{\s*toISOStringSafe\s*}\s*from\s*["']\.\.\/util\/toISOStringSafe["']\s*;?\s*/gm,
-      "",
-    )
-    // JWT imports (if LLM adds them)
-    .replace(/import\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm, "")
-    .replace(
-      /import\s*\*\s*as\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm,
-      "",
-    );
-
-  // Remove API structure imports with wrong paths
-  // Pattern 1: ../api/structures path (LLM often uses this wrong path)
-  cleanedCode = cleanedCode.replace(
-    /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']\.\.\/api\/structures\/[^"']+["']\s*;?\s*/gm,
-    "",
-  );
-  // Pattern 2: @ORGANIZATION/PROJECT-api path (correct path but LLM shouldn't write it)
-  cleanedCode = cleanedCode.replace(
-    /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']@ORGANIZATION\/PROJECT-api\/lib\/structures\/[^"']+["']\s*;?\s*/gm,
-    "",
-  );
-
-  // Remove specific type imports that match our typeReferences
-  for (const ref of typeReferences) {
-    const typeImportRegex = new RegExp(
-      `import\\s*(?:type\\s*)?{\\s*${ref}\\s*}\\s*from\\s*["'][^"']+["']\\s*;?\\s*`,
-      "gm",
-    );
-    cleanedCode = cleanedCode.replace(typeImportRegex, "");
-  }
-
-  // Remove decorator type imports if LLM mistakenly added them
-  if (decoratorType) {
-    const decoratorTypeRegex = new RegExp(
-      `import\\s*(?:type\\s*)?{\\s*${decoratorType}\\s*}\\s*from\\s*["']\\.\\.\/decorators\/payload\/${decoratorType}["']\\s*;?\\s*`,
-      "gm",
-    );
-    cleanedCode = cleanedCode.replace(decoratorTypeRegex, "");
-  }
-
-  return cleanedCode;
-}
+// /**
+//  * Removes all import statements that LLM might have incorrectly added. This
+//  * includes standard library imports, auto-injected imports, and any API
+//  * structure imports with wrong paths.
+//  *
+//  * @param code - The code containing imports to remove
+//  * @param typeReferences - List of type names to specifically remove
+//  * @param decoratorType - Optional decorator type to remove
+//  * @returns Code with all imports removed
+//  */
+// function removeAllImports(
+//   code: string,
+//   typeReferences: string[],
+//   decoratorType?: string,
+// ): string {
+//   // Remove standard library and auto-injected imports
+//   let cleanedCode = code
+//     // MyGlobal - often with wrong path
+//     .replace(
+//       /import\s*{\s*MyGlobal\s*}\s*from\s*["']\.\.\/MyGlobal["']\s*;?\s*/gm,
+//       "",
+//     )
+//     // typia - various import patterns
+//     .replace(
+//       /import\s+typia\s*,\s*{\s*tags\s*}\s*from\s*["']typia["']\s*;?\s*/gm,
+//       "",
+//     )
+//     .replace(/import\s*{\s*tags\s*}\s*from\s*["']typia["']\s*;?\s*/gm, "")
+//     .replace(
+//       /import\s*{\s*tags\s*,\s*typia\s*}\s*from\s*["']typia["']\s*;?\s*/gm,
+//       "",
+//     )
+//     .replace(/import\s+typia\s*from\s*["']typia["']\s*;?\s*/gm, "")
+//     // Prisma client
+//     .replace(
+//       /import\s*{\s*Prisma\s*}\s*from\s*["']@prisma\/client["']\s*;?\s*/gm,
+//       "",
+//     )
+//     // uuid
+//     .replace(/import\s*{\s*v4\s*}\s*from\s*["']uuid["']\s*;?\s*/gm, "")
+//     // toISOStringSafe utility
+//     .replace(
+//       /import\s*{\s*toISOStringSafe\s*}\s*from\s*["']\.\.\/utils\/toISOStringSafe["']\s*;?\s*/gm,
+//       "",
+//     )
+//     // JWT imports (if LLM adds them)
+//     .replace(/import\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm, "")
+//     .replace(
+//       /import\s*\*\s*as\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm,
+//       "",
+//     )
+//     // NestJS HttpException
+//     .replace(
+//       /import\s*{\s*HttpException\s*}\s*from\s*["']@nestjs\/common["']\s*;?\s*/gm,
+//       "",
+//     );
+
+//   // Remove API structure imports with wrong paths
+//   // Pattern 1: ../api/structures path (LLM often uses this wrong path)
+//   cleanedCode = cleanedCode.replace(
+//     /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']\.\.\/api\/structures\/[^"']+["']\s*;?\s*/gm,
+//     "",
+//   );
+//   // Pattern 2: @ORGANIZATION/PROJECT-api path (correct path but LLM shouldn't write it)
+//   cleanedCode = cleanedCode.replace(
+//     /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']@ORGANIZATION\/PROJECT-api\/lib\/structures\/[^"']+["']\s*;?\s*/gm,
+//     "",
+//   );
+
+//   // Remove specific type imports that match our typeReferences
+//   for (const ref of typeReferences) {
+//     const typeImportRegex = new RegExp(
+//       `import\\s*(?:type\\s*)?{\\s*${ref}\\s*}\\s*from\\s*["'][^"']+["']\\s*;?\\s*`,
+//       "gm",
+//     );
+//     cleanedCode = cleanedCode.replace(typeImportRegex, "");
+//   }
+
+//   // Remove decorator type imports if LLM mistakenly added them
+//   if (decoratorType) {
+//     const decoratorTypeRegex = new RegExp(
+//       `import\\s*(?:type\\s*)?{\\s*${decoratorType}\\s*}\\s*from\\s*["']\\.\\.\/decorators\/payload\/${decoratorType}["']\\s*;?\\s*`,
+//       "gm",
+//     );
+//     cleanedCode = cleanedCode.replace(decoratorTypeRegex, "");
+//   }
+
+//   return cleanedCode;
+// }
 
 export async function replaceImportStatements<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
     operation: AutoBeOpenApi.IOperation;
+    schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
     code: string;
     decoratorType?: string;
   },
-) {
-  let { operation, code, decoratorType } = props;
-
-  // Extract type references from operation
-  const typeReferences: string[] = Array.from(
-    new Set(
-      [operation.requestBody, operation.responseBody]
-        .filter((el) => el !== null)
-        .map((el) => el.typeName.split(".")[0]!),
-    ),
-  );
+): Promise<string> {
+  let { code, decoratorType } = props;
 
   // Beautify code first for consistent formatting
   const compiler: IAutoBeCompiler = await ctx.compiler();
   code = await compiler.typescript.beautify(code);
 
   // Remove all LLM-generated imports
-  code = removeAllImports(code, typeReferences, decoratorType);
+  code = code
+    .split("\r\n")
+    .join("\n")
+    .split("\n")
+    .filter((str) => str.trim().startsWith("import") === false)
+    .join("\n");
 
   // Build the standard imports
-  const imports = getRealizeWriteImportStatements(operation);
+  const imports = getRealizeWriteImportStatements(props);
 
   // Only add decoratorType import if it exists
   if (decoratorType) {

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

@@ -13,8 +13,11 @@ export const transformTestCorrectHistories = async <
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  func: IAutoBeTestFunction,
-  failures: IAutoBeTestFunctionFailure[],
+  props: {
+    instruction: string;
+    function: IAutoBeTestFunction;
+    failures: IAutoBeTestFunctionFailure[];
+  },
 ): Promise<
   Array<
     IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
@@ -22,7 +25,11 @@ export const transformTestCorrectHistories = async <
 > => {
   const previous: Array<
     IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-  > = await transformTestWriteHistories(ctx, func.scenario, func.artifacts);
+  > = await transformTestWriteHistories(ctx, {
+    instruction: props.instruction,
+    scenario: props.function.scenario,
+    artifacts: props.function.artifacts,
+  });
   return [
     ...previous.slice(0, -1),
     {
@@ -32,21 +39,21 @@ export const transformTestCorrectHistories = async <
       text: AutoBeSystemPromptConstant.TEST_CORRECT,
     },
     previous.at(-1)!,
-    ...failures.map(
+    ...props.failures.map(
       (f, i, array) =>
         ({
           id: v7(),
           created_at: new Date().toISOString(),
           type: "assistantMessage",
           text: StringUtil.trim`
-            # ${i === array.length - 1 ? "Latest Failure" : "Previous Failure"}
-            ## Generated TypeScript Code
+            ## ${i === array.length - 1 ? "Latest Failure" : "Previous Failure"}
+            ### Generated TypeScript Code
 
             \`\`\`typescript
             ${f.function.script}
             \`\`\`
 
-            ## Compile Errors
+            ### Compile Errors
 
             Fix the compilation error in the provided code.
 

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

@@ -6,36 +6,21 @@ import { v7 } from "uuid";
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
 import { IAutoBeTestScenarioAuthorizationRole } from "../structures/IAutoBeTestScenarioAuthorizationRole";
-import { getReferenceIds } from "../utils/getReferenceIds";
-
-export const transformTestScenarioHistories = (
-  state: AutoBeState,
-  document: AutoBeOpenApi.IDocument,
-  include: AutoBeOpenApi.IOperation[],
-  exclude: Pick<AutoBeOpenApi.IOperation, "method" | "path">[],
-): Array<
+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
 > => {
-  interface IRelationship {
-    endpoint: AutoBeOpenApi.IEndpoint;
-    ids: string[];
-  }
   const authorizations: AutoBeInterfaceAuthorization[] =
-    state.interface?.authorizations ?? [];
+    props.state.interface?.authorizations ?? [];
   const authorizationRoles: Map<string, IAutoBeTestScenarioAuthorizationRole> =
     new Map();
-  const relationships: IRelationship[] = document.operations
-    .map((o) => ({
-      endpoint: {
-        method: o.method,
-        path: o.path,
-      },
-      ids: getReferenceIds({
-        document,
-        operation: o,
-      }),
-    }))
-    .filter((v) => v.ids.length !== 0);
 
   for (const authorization of authorizations) {
     for (const op of authorization.operations) {
@@ -66,7 +51,22 @@ export const transformTestScenarioHistories = (
       created_at: new Date().toISOString(),
       type: "assistantMessage",
       text: StringUtil.trim`
-        # API Operations
+        ## Instructions
+
+        The following e2e-test-specific instructions were extracted by AI 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.
+        
+        Apply these instructions when generating test scenarios to ensure the
+        tests align with the user's testing requirements and expectations.
+        If any instructions are not relevant to the target API operations,
+        you may ignore them.
+
+        ${props.instruction}
+
+        ## API Operations
 
         Below are the complete API operations.
         Use this information to understand capabilities and dependency relationships.
@@ -76,109 +76,44 @@ export const transformTestScenarioHistories = (
         You may write multiple scenarios for a single included endpoint.
         Focus on business-logic-oriented E2E flows rather than trivial CRUD.
 
-        Please analyze the operations to identify all dependencies required for testing.
-        Pay close attention to IDs and related values in the API,
-        and ensure you identify all dependencies between endpoints.
-
         \`\`\`json
-        ${JSON.stringify({ operations: document.operations })}
+        ${JSON.stringify({
+          operations: props.document.operations,
+        })}
         \`\`\`
-      `,
-    } satisfies IAgenticaHistoryJson.IAssistantMessage,
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
-        # Included in Test Plan
+
+        ## 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.
 
-        Generate test scenarios only for these included endpoints. Do not create scenarios for excluded endpoints. Operations not listed here may be used only as dependencies.
-
-        ${include
-          .map((el, i) => {
-            const roles = Array.from(authorizationRoles.values()).filter(
+        \`\`\`json
+        ${JSON.stringify(
+          props.include.map((el) => ({
+            ...el,
+            prerequisites: getPrerequisites({
+              document: props.document,
+              endpoint: el,
+            }),
+            authorizationRoles: Array.from(authorizationRoles.values()).filter(
               (role) => role.name === el.authorizationRole,
-            );
-
-            const requiredIds = getReferenceIds({ document, operation: el });
-
-            return StringUtil.trim`
-              ## ${i + 1}. ${el.method.toUpperCase()} ${el.path}
-
-              Related Authentication APIs:
-
-              ${
-                roles.length > 0
-                  ? roles
-                      .map((role) => {
-                        return StringUtil.trim`
-                          - ${role.join?.method.toUpperCase()}: ${role.join?.path}
-                          - ${role.login?.method.toUpperCase()}: ${role.login?.path}
-                        `;
-                      })
-                      .join("\n")
-                  : "- None"
-              }
-
-              Required IDs:
-              
-              - ${
-                requiredIds.length > 0
-                  ? requiredIds.map((id) => `\`${id}\``).join(", ")
-                  : "None"
-              }
-            `;
-          })
-          .join("\n")}
-
-        # Excluded from Test Plan
+            ),
+          })),
+        )}
+        \`\`\`
+
+        ## 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.
 
-        ${exclude
-          .map((el) => `- ${el.method.toUpperCase()}: ${el.path}`)
-          .join("\n")}
-      `,
-    } satisfies IAgenticaHistoryJson.IAssistantMessage,
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
-        # Candidate Dependencies
-    
-        List of candidate dependencies extracted from path parameters and request bodies.
-
-        Apply dependency resolution to the target endpoint from "Included in Test Plan" and to dependencies found recursively from it.
-        For each required ID, locate the operation that creates the resource. Include the creator only if that operation exists in the provided operations list. Do not assume or invent operations. If no creator exists, treat the ID as an external or pre-existing input.
-
-        Dependency resolution steps:
-        1. Starting from the target endpoint, collect required IDs.
-        2. For each ID, search for a creator operation (typically POST).
-        3. If found, add it to the dependency chain in execution order and repeat for its own required IDs.
-        4. Stop when no further creators exist or are needed.
-
-        For each some_entity_id pattern, use the same approach: include a creator only when it is present in the operations list.
-    
-        Endpoint | Required IDs (MUST be created by other APIs)
-        ---------|---------------------------------------------------
-        ${relationships
-          .map((r) =>
-            [
-              `\`${r.endpoint.method} ${r.endpoint.path}\``,
-              r.ids.map((id) => `\`${id}\``).join(", "),
-            ].join(" | "),
-          )
-          .join("\n")}
-
-        Example: If an endpoint requires \`articleId\` and \`POST /articles\` exists, include it in dependencies
+        \`\`\`json
+        ${JSON.stringify(props.exclude)}
+        \`\`\`
+
       `,
     } satisfies IAgenticaHistoryJson.IAssistantMessage,
   ];

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

@@ -1,50 +1,35 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBeOpenApi } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
-import { ILlmSchema } from "@samchon/openapi";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
-import { AutoBeContext } from "../../../context/AutoBeContext";
+import { AutoBeState } from "../../../context/AutoBeState";
 import { IAutoBeTestScenarioApplication } from "../structures/IAutoBeTestScenarioApplication";
-import { getReferenceIds } from "../utils/getReferenceIds";
+import { getPrerequisites } from "../utils/getPrerequisites";
 
-export function transformTestScenarioReviewHistories<
-  Model extends ILlmSchema.Model,
->(
-  ctx: AutoBeContext<Model>,
-  groups: IAutoBeTestScenarioApplication.IScenarioGroup[],
-): Array<
+export function transformTestScenarioReviewHistories(props: {
+  state: AutoBeState;
+  instruction: string;
+  groups: IAutoBeTestScenarioApplication.IScenarioGroup[];
+}): Array<
   IAgenticaHistoryJson.ISystemMessage | IAgenticaHistoryJson.IAssistantMessage
 > {
-  interface IRelationship {
-    endpoint: AutoBeOpenApi.IEndpoint;
-    ids: string[];
-  }
-
   const document: AutoBeOpenApi.IDocument | undefined =
-    ctx.state().interface?.document;
-
+    props.state.interface?.document;
   if (document === undefined) {
     throw new Error(
       "Cannot review test scenarios because there are no operations.",
     );
   }
 
-  const relationships: IRelationship[] = document.operations
-    .map((o) => ({
-      endpoint: {
-        method: o.method,
-        path: o.path,
-      },
-      ids: getReferenceIds({
-        document,
-        operation: o,
-      }),
-    }))
-    .filter((v) => v.ids.length !== 0);
-
   return [
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.TEST_SCENARIO,
+    },
     {
       id: v7(),
       created_at: new Date().toISOString(),
@@ -56,7 +41,22 @@ export function transformTestScenarioReviewHistories<
       created_at: new Date().toISOString(),
       type: "assistantMessage",
       text: StringUtil.trim`
-        # Available API Operations for Reference
+        ## Instructions
+
+        The following e2e-test-specific instructions were extracted by AI 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.
+        
+        Apply these instructions when reviewing test scenarios to ensure the
+        tests align with the user's testing requirements and expectations.
+        If any instructions are not relevant to the target API operations,
+        you may ignore them.
+
+        ${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.
@@ -64,93 +64,23 @@ export function transformTestScenarioReviewHistories<
         \`\`\`json
         ${JSON.stringify({ operations: document.operations })}
         \`\`\`
-      `,
-    },
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
 
-      # Test Scenario Groups
+        ## Test Scenario Groups to Review
 
-      Please review the following test scenario groups:
+        Each scenario group includes the target endpoint and its prerequisite endpoints.
 
-      \`\`\`json
-      ${JSON.stringify(
-        groups.map((g) => {
-          return {
+        \`\`\`json
+        ${JSON.stringify(
+          props.groups.map((g) => ({
             ...g,
-            scenarios: g.scenarios.map((s) => {
-              const requiredId: string[] = [];
-
-              s.dependencies.forEach((dep) => {
-                document.operations.forEach((op) => {
-                  if (
-                    g.endpoint.method === op.method &&
-                    g.endpoint.path === op.path
-                  ) {
-                    requiredId.push(
-                      ...getReferenceIds({ document, operation: op }),
-                    );
-                  }
-
-                  if (
-                    op.method === dep.endpoint.method &&
-                    op.path === dep.endpoint.path
-                  ) {
-                    requiredId.push(
-                      ...getReferenceIds({ document, operation: op }),
-                    );
-                  }
-                });
-              });
-
-              return {
-                ...s,
-                requiredIds:
-                  requiredId.length > 0 ? Array.from(new Set(requiredId)) : [],
-              };
+            prerequisites: getPrerequisites({
+              document,
+              endpoint: g.endpoint,
             }),
-          };
-        }),
-      )}
-      \`\`\`
+          })),
+        )}
+        \`\`\`
       `,
     },
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
-        # Candidate Dependencies
-    
-        List of candidate dependencies extracted from path parameters and request bodies.
-
-        Apply dependency resolution to the target endpoint from "Included in Test Plan" and to dependencies found recursively from it.
-        For each required ID, locate the operation that creates the resource. Include the creator only if that operation exists in the provided operations list. Do not assume or invent operations. If no creator exists, treat the ID as an external or pre-existing input.
-
-        Dependency resolution steps:
-        1. Starting from the target endpoint, collect required IDs.
-        2. For each ID, search for a creator operation (typically POST).
-        3. If found, add it to the dependency chain in execution order and repeat for its own required IDs.
-        4. Stop when no further creators exist or are needed.
-
-        For each some_entity_id pattern, use the same approach: include a creator only when it is present in the operations list.
-    
-        Endpoint | Required IDs (MUST be created by other APIs)
-        ---------|---------------------------------------------------
-        ${relationships
-          .map((r) =>
-            [
-              `\`${r.endpoint.method} ${r.endpoint.path}\``,
-              r.ids.map((id) => `\`${id}\``).join(", "),
-            ].join(" | "),
-          )
-          .join("\n")}
-
-        Example: If an endpoint requires \`articleId\` and \`POST /articles\` exists, include it in dependencies
-      `,
-    } satisfies IAgenticaHistoryJson.IAssistantMessage,
   ];
 }