@autobe/agent 0.25.0 → 0.25.2

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

@@ -20,9 +20,9 @@ import { getRealizeWriteImportStatements } from "./getRealizeWriteImportStatemen
  *   import { MyGlobal } from "../MyGlobal";
  *   // ... other imports
  *
- *   async function post__users_create(
+ *   async function post__users_create(props: {
  *     body: IUserCreateRequest
- *   ): Promise<IUserResponse> {
+ *   }): Promise<IUserResponse> {
  *     ...
  *   }
  *   ```;
@@ -32,35 +32,31 @@ import { getRealizeWriteImportStatements } from "./getRealizeWriteImportStatemen
  * @param authorization - Authorization context if endpoint is authenticated
  * @returns Complete TypeScript code template as a formatted string
  */
-export function getRealizeWriteCodeTemplate(
-  scenario: IAutoBeRealizeScenarioResult,
-  operation: AutoBeOpenApi.IOperation,
-  authorization: AutoBeRealizeAuthorization | null,
-): string {
+export function getRealizeWriteCodeTemplate(props: {
+  scenario: IAutoBeRealizeScenarioResult;
+  operation: AutoBeOpenApi.IOperation;
+  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+  authorization: AutoBeRealizeAuthorization | null;
+}): string {
   // Collect all function parameters in order
   const functionParameters: string[] = [];
 
   // Add authentication parameter if needed (e.g., user: IUser, admin: IAdmin)
-  if (authorization && authorization.role.name) {
+  if (props.authorization && props.authorization.role.name) {
     // Debug: Log the values to check what's being used
-    const authParameter = `${authorization.role.name}: ${authorization.payload.name}`;
+    const authParameter = `${props.authorization.role.name}: ${props.authorization.payload.name}`;
     functionParameters.push(authParameter);
   }
 
   // Add path parameters (e.g., id, postId, etc.)
-  const pathParameters = operation.parameters.map((param) => {
-    const paramType = param.schema.type;
-    const paramFormat =
-      "format" in param.schema
-        ? ` & tags.Format<'${param.schema.format}'>`
-        : "";
-    return `${param.name}: ${paramType}${paramFormat}`;
+  const pathParameters = props.operation.parameters.map((param) => {
+    return `${param.name}: ${writeParameterType(param.schema)}`;
   });
   functionParameters.push(...pathParameters);
 
   // Add request body parameter if present
-  if (operation.requestBody?.typeName) {
-    const bodyParameter = `body: ${operation.requestBody.typeName}`;
+  if (props.operation.requestBody?.typeName) {
+    const bodyParameter = `body: ${props.operation.requestBody.typeName}`;
     functionParameters.push(bodyParameter);
   }
 
@@ -79,19 +75,55 @@ export function getRealizeWriteCodeTemplate(
   }
 
   // Determine return type
-  const returnType = operation.responseBody?.typeName ?? "void";
+  const returnType = props.operation.responseBody?.typeName ?? "void";
 
   // Generate the complete template
   return StringUtil.trim`
     Complete the code below, disregard the import part and return only the function part.
 
     \`\`\`typescript
-    ${getRealizeWriteImportStatements(operation).join("\n")} 
+    ${getRealizeWriteImportStatements(props).join("\n")} 
 
-    // ONLY YOU HAVE TO WRITE THIS, AND USE IMPORTED.
-    export async function ${scenario.functionName}(${formattedSignature}): Promise<${returnType}> {
+    // DON'T CHANGE FUNCTION NAME AND PARAMETERS,
+    // ONLY YOU HAVE TO WRITE THIS FUNCTION BODY, AND USE IMPORTED.
+    export async function ${props.scenario.functionName}(${formattedSignature}): Promise<${returnType}> {
       ...
     }
     \`\`\`
   `;
 }
+
+const writeParameterType = (
+  schema: AutoBeOpenApi.IParameter["schema"],
+): string => {
+  const elements: string[] =
+    schema.type === "integer"
+      ? ["number", `tags.Type<"int32">`]
+      : [schema.type];
+  if (schema.type === "number") {
+    if (schema.minimum !== undefined)
+      elements.push(`tags.Minimum<${schema.minimum}>`);
+    if (schema.maximum !== undefined)
+      elements.push(`tags.Maximum<${schema.maximum}>`);
+    if (schema.exclusiveMinimum !== undefined)
+      elements.push(`tags.ExclusiveMinimum<${schema.exclusiveMinimum}>`);
+    if (schema.exclusiveMaximum !== undefined)
+      elements.push(`tags.ExclusiveMaximum<${schema.exclusiveMaximum}>`);
+    if (schema.multipleOf !== undefined)
+      elements.push(`tags.MultipleOf<${schema.multipleOf}>`);
+  } else if (schema.type === "string") {
+    if (schema.format !== undefined)
+      elements.push(`tags.Format<${JSON.stringify(schema.format)}>`);
+    if (schema.contentMediaType !== undefined)
+      elements.push(
+        `tags.ContentMediaType<${JSON.stringify(schema.contentMediaType)}>`,
+      );
+    if (schema.pattern !== undefined)
+      elements.push(`tags.Pattern<${JSON.stringify(schema.pattern)}>`);
+    if (schema.minLength !== undefined)
+      elements.push(`tags.MinLength<${schema.minLength}>`);
+    if (schema.maxLength !== undefined)
+      elements.push(`tags.MaxLength<${schema.maxLength}>`);
+  }
+  return elements.join(" & ");
+};

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

@@ -1,30 +1,42 @@
 import { AutoBeOpenApi } from "@autobe/interface";
+import { OpenApiTypeChecker } from "@samchon/openapi";
 
-export function getRealizeWriteImportStatements(
-  operation: AutoBeOpenApi.IOperation,
-) {
-  const typeReferences: string[] = Array.from(
-    new Set(
-      [operation.requestBody, operation.responseBody]
-        .filter((el) => el !== null)
-        .map((el) => el.typeName.split(".")[0]!),
-    ),
-  );
+export function getRealizeWriteImportStatements(props: {
+  operation: AutoBeOpenApi.IOperation;
+  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+}): string[] {
+  const typeReferences: Set<string> = new Set();
+  const visit = (key: string) =>
+    OpenApiTypeChecker.visit({
+      schema: {
+        $ref: `#/components/schemas/${key}`,
+      },
+      components: { schemas: props.schemas },
+      closure: (next) => {
+        if (OpenApiTypeChecker.isReference(next))
+          typeReferences.add(next.$ref.split("/").pop()!.split(".")[0]!);
+      },
+    });
+  if (props.operation.requestBody) visit(props.operation.requestBody.typeName);
+  if (props.operation.responseBody)
+    visit(props.operation.responseBody.typeName);
 
   // Build the standard imports
   const imports = [
+    'import { HttpException } from "@nestjs/common";',
+    'import { Prisma } from "@prisma/client";',
     'import jwt from "jsonwebtoken";',
-    'import { MyGlobal } from "../MyGlobal";',
     'import typia, { tags } from "typia";',
-    'import { Prisma } from "@prisma/client";',
     'import { v4 } from "uuid";',
-    'import { toISOStringSafe } from "../util/toISOStringSafe"',
-    'import { HttpException } from "@nestjs/common";',
-    ...typeReferences.map(
+
+    'import { MyGlobal } from "../MyGlobal";',
+    'import { PasswordUtil } from "../utils/PasswordUtil";',
+    'import { toISOStringSafe } from "../utils/toISOStringSafe"',
+    "",
+    ...Array.from(typeReferences).map(
       (ref) =>
         `import { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,
     ),
   ];
-
   return imports;
 }

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

@@ -0,0 +1,55 @@
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+
+/**
+ * Prints error hints for a given code and its diagnostics.
+ *
+ * @param code The code to analyze.
+ * @param diagnostics The diagnostics to use for error hinting.
+ */
+export function printErrorHints(
+  code: string,
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
+): string {
+  const lines: string[] = code.split("\n");
+
+  let cursor: number = 0;
+  const hints: string[] = [];
+  lines.forEach((line, index, arr) => {
+    const lineStart = cursor;
+    cursor += line.length + 1; // +1 for the newline character
+
+    diagnostics.forEach((diag) => {
+      if (diag.start === null || diag.start === undefined) {
+        return;
+      }
+
+      // Check if the diagnostic start position falls within the current line
+      if (diag.start >= lineStart && diag.start < cursor) {
+        // Handle multi-line error messages by escaping newlines
+        const errorMessage = String(diag.messageText).replace(/\n/g, "\\n");
+        const targetLine = line + " // error: " + errorMessage;
+
+        // targetLine만 덮어써서 새로운 배열을 만들어야 한다.
+        const hint: string = arr
+          .slice(0, index)
+          .concat(targetLine)
+          .concat(arr.slice(index + 1))
+          .join("\n");
+
+        hints.push(hint);
+      }
+    });
+  });
+
+  return hints
+    .map((h, i) => {
+      return StringUtil.trim`
+        hint #${i + 1}:
+        \`\`\`typescript
+        ${h}
+        \`\`\`
+      `;
+    })
+    .join("\n");
+}

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

@@ -4,124 +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,
-      "",
-    )
-    // 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;
-}
+// /**
+//  * 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/transformTestScenarioHistories.ts

@@ -6,7 +6,7 @@ import { v7 } from "uuid";
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
 import { IAutoBeTestScenarioAuthorizationRole } from "../structures/IAutoBeTestScenarioAuthorizationRole";
-import { getReferenceIds } from "../utils/getReferenceIds";
+import { getPrerequisites } from "../utils/getPrerequisites";
 
 export const transformTestScenarioHistories = (props: {
   state: AutoBeState;
@@ -17,26 +17,10 @@ export const transformTestScenarioHistories = (props: {
 }): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
-  interface IRelationship {
-    endpoint: AutoBeOpenApi.IEndpoint;
-    ids: string[];
-  }
   const authorizations: AutoBeInterfaceAuthorization[] =
     props.state.interface?.authorizations ?? [];
   const authorizationRoles: Map<string, IAutoBeTestScenarioAuthorizationRole> =
     new Map();
-  const relationships: IRelationship[] = props.document.operations
-    .map((operation) => ({
-      endpoint: {
-        method: operation.method,
-        path: operation.path,
-      },
-      ids: getReferenceIds({
-        document: props.document,
-        operation,
-      }),
-    }))
-    .filter((v) => v.ids.length !== 0);
 
   for (const authorization of authorizations) {
     for (const op of authorization.operations) {
@@ -92,10 +76,6 @@ export const transformTestScenarioHistories = (props: {
         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: props.document.operations,
@@ -109,46 +89,20 @@ export const transformTestScenarioHistories = (props: {
         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.
-
-        ${props.include
-          .map((el, i) => {
-            const roles = Array.from(authorizationRoles.values()).filter(
-              (role) => role.name === el.authorizationRole,
-            );
-
-            const requiredIds = getReferenceIds({
+        \`\`\`json
+        ${JSON.stringify(
+          props.include.map((el) => ({
+            ...el,
+            prerequisites: getPrerequisites({
               document: props.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")}
+              endpoint: el,
+            }),
+            authorizationRoles: Array.from(authorizationRoles.values()).filter(
+              (role) => role.name === el.authorizationRole,
+            ),
+          })),
+        )}
+        \`\`\`
 
         ## Excluded from Test Plan
 
@@ -156,37 +110,10 @@ export const transformTestScenarioHistories = (props: {
         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.
 
-        ${props.exclude
-          .map((el) => `- ${el.method.toUpperCase()}: ${el.path}`)
-          .join("\n")}
-
-        ## 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,
   ];