@autobe/agent 0.30.0-dev.20260315 → 0.30.1

package/lib/orchestrate/interface/histories/transformInterfacePrerequisiteHistory.js

@@ -36,36 +36,36 @@ const transformInterfacePrerequisiteHistory = (props) => {
                 type: "assistantMessage",
                 id: (0, uuid_1.v7)(),
                 created_at: new Date().toISOString(),
-                text: utils_1.StringUtil.trim `
-          ## Target Operation
-
-          Single operation requiring prerequisite analysis.
-
-          Analyze if this operation needs any prerequisites from the available
-          operations above. Add prerequisites only when there are genuine
-          dependencies like resource existence checks or state validations.
-
-          \`\`\`json
-          ${JSON.stringify(props.operation)}
-          \`\`\`
-
-          Also, here is the list of reference IDs found in the target 
-          operation's path parameters.
-
+                text: utils_1.StringUtil.trim `
+          ## Target Operation
+
+          Single operation requiring prerequisite analysis.
+
+          Analyze if this operation needs any prerequisites from the available
+          operations above. Add prerequisites only when there are genuine
+          dependencies like resource existence checks or state validations.
+
+          \`\`\`json
+          ${JSON.stringify(props.operation)}
+          \`\`\`
+
+          Also, here is the list of reference IDs found in the target 
+          operation's path parameters.
+
           ${(0, getReferenceIds_1.getReferenceIds)({
                     document: props.document,
                     operation: props.operation,
                 })
                     .map((id) => `- ${id}`)
-                    .join("\n") || "- None"}
-
-          ### Domain Schemas
-
-          Schema definitions for the target operation.
-
-          \`\`\`json
-          ${JSON.stringify(domainSchemas)}
-          \`\`\`
+                    .join("\n") || "- None"}
+
+          ### Domain Schemas
+
+          Schema definitions for the target operation.
+
+          \`\`\`json
+          ${JSON.stringify(domainSchemas)}
+          \`\`\`
         `,
             },
         ],

package/lib/orchestrate/interface/histories/transformInterfaceSchemaCastingHistory.js

@@ -22,82 +22,82 @@ const transformInterfaceSchemaCastingHistory = (props) => ({
             type: "assistantMessage",
             id: (0, uuid_1.v7)(),
             created_at: new Date().toISOString(),
-            text: utils_1.StringUtil.trim `
-        ## API Design Instructions
-
-        The following API-specific instructions were extracted from
-        the user's requirements. These focus on API interface design aspects
-        relevant to the schema refinement task.
-
-        Follow these instructions when analyzing and refining schemas.
-        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}
+            text: utils_1.StringUtil.trim `
+        ## API Design Instructions
+
+        The following API-specific instructions were extracted from
+        the user's requirements. These focus on API interface design aspects
+        relevant to the schema refinement task.
+
+        Follow these instructions when analyzing and refining schemas.
+        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}
       `,
         },
         {
             id: (0, uuid_1.v7)(),
             type: "assistantMessage",
             created_at: new Date().toISOString(),
-            text: utils_1.StringUtil.trim `
-        ## Target Type for Refinement Analysis
-
-        You are analyzing the following type alias to determine if it is a
-        **degenerate primitive type** that should be refined into a proper
-        object schema.
-
-        ### Type Name: \`${props.typeName}\`
-
-        ### Current Schema Definition:
-
-        \`\`\`json
-        ${JSON.stringify(props.originalSchema, null, 2)}
-        \`\`\`
-
-        ### Operations Using This Type
-
-        The following API operations reference this type. Use this context
-        to understand how the type is used:
-
-        \`\`\`json
-        ${JSON.stringify(props.refineOperations, null, 2)}
-        \`\`\`
-
-        ## Your Task
-
-        Analyze this type using the Chain-of-Thought process:
-
-        1. **Observation**: Document what you see - the current type, JSDoc/description,
-           database hints, and naming patterns.
-
-        2. **Reasoning**: Analyze whether the documentation/naming contradicts the
-           primitive type. Look for keywords like "key/value", "list of", "contains",
-           "mapping", "distribution", "preferences", etc.
-
-        3. **Verdict**: State your conclusion - is this DEGENERATE (needs refinement)
-           or INTENTIONAL (valid primitive alias)?
-
-        4. **Schema**: If DEGENERATE, provide the correct object schema.
-           If INTENTIONAL, set to null.
-
-        ## Important Guidelines
-
-        - **REFINE** if: Documentation describes a structure (Record, Array, Object)
-          but type is primitive.
-        - **KEEP** if: This is a valid semantic alias (e.g., \`IUserId = string\`,
-          \`IItemCount = number\`).
-        - Always provide detailed observation and reasoning to justify your decision.
+            text: utils_1.StringUtil.trim `
+        ## Target Type for Refinement Analysis
+
+        You are analyzing the following type alias to determine if it is a
+        **degenerate primitive type** that should be refined into a proper
+        object schema.
+
+        ### Type Name: \`${props.typeName}\`
+
+        ### Current Schema Definition:
+
+        \`\`\`json
+        ${JSON.stringify(props.originalSchema, null, 2)}
+        \`\`\`
+
+        ### Operations Using This Type
+
+        The following API operations reference this type. Use this context
+        to understand how the type is used:
+
+        \`\`\`json
+        ${JSON.stringify(props.refineOperations, null, 2)}
+        \`\`\`
+
+        ## Your Task
+
+        Analyze this type using the Chain-of-Thought process:
+
+        1. **Observation**: Document what you see - the current type, JSDoc/description,
+           database hints, and naming patterns.
+
+        2. **Reasoning**: Analyze whether the documentation/naming contradicts the
+           primitive type. Look for keywords like "key/value", "list of", "contains",
+           "mapping", "distribution", "preferences", etc.
+
+        3. **Verdict**: State your conclusion - is this DEGENERATE (needs refinement)
+           or INTENTIONAL (valid primitive alias)?
+
+        4. **Schema**: If DEGENERATE, provide the correct object schema.
+           If INTENTIONAL, set to null.
+
+        ## Important Guidelines
+
+        - **REFINE** if: Documentation describes a structure (Record, Array, Object)
+          but type is primitive.
+        - **KEEP** if: This is a valid semantic alias (e.g., \`IUserId = string\`,
+          \`IItemCount = number\`).
+        - Always provide detailed observation and reasoning to justify your decision.
       `,
         },
     ],
-    userMessage: utils_1.StringUtil.trim `
-    Review \`${props.typeName}\` type and convert it to a proper object type if needed.
+    userMessage: utils_1.StringUtil.trim `
+    Review \`${props.typeName}\` type and convert it to a proper object type if needed.
   `,
 });
 exports.transformInterfaceSchemaCastingHistory = transformInterfaceSchemaCastingHistory;

package/lib/orchestrate/interface/histories/transformInterfaceSchemaComplementHistory.js

@@ -29,37 +29,37 @@ const transformInterfaceSchemaComplementHistory = (props) => ({
             type: "assistantMessage",
             id: (0, uuid_1.v7)(),
             created_at: new Date().toISOString(),
-            text: utils_1.StringUtil.trim `
-        ## API Design Instructions
-
-        The following API-specific instructions were extracted from
-        the user's requirements. These focus on API interface design aspects
-        such as endpoint patterns, request/response formats, DTO schemas,
-        and operation specifications.
-
-        Follow these instructions when completing missing schema types.
-        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}
-
-        ## Missed Type
-
-        You need to create a schema definition for this missing type:
-
-        **${props.typeName}**
-
-        This type is referenced in API operations but not yet defined in
-        components.schemas. Create a complete JSON schema definition for it.
+            text: utils_1.StringUtil.trim `
+        ## API Design Instructions
+
+        The following API-specific instructions were extracted from
+        the user's requirements. These focus on API interface design aspects
+        such as endpoint patterns, request/response formats, DTO schemas,
+        and operation specifications.
+
+        Follow these instructions when completing missing schema types.
+        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}
+
+        ## Missed Type
+
+        You need to create a schema definition for this missing type:
+
+        **${props.typeName}**
+
+        This type is referenced in API operations but not yet defined in
+        components.schemas. Create a complete JSON schema definition for it.
       `,
         },
     ],
-    userMessage: utils_1.StringUtil.trim `
-    Complete the missing schema type ${JSON.stringify(props.typeName)}.
+    userMessage: utils_1.StringUtil.trim `
+    Complete the missing schema type ${JSON.stringify(props.typeName)}.
   `,
 });
 exports.transformInterfaceSchemaComplementHistory = transformInterfaceSchemaComplementHistory;
@@ -78,38 +78,38 @@ const transformReferenceHistory = (props) => {
         type: "assistantMessage",
         id: (0, uuid_1.v7)(),
         created_at: new Date().toISOString(),
-        text: utils_1.StringUtil.trim `
-      ## Existing Schema References
-
-      The missing type **${props.typeName}** is referenced in the following locations
-      within existing schema definitions. Use these references to understand the context,
-      purpose, and expected structure of the missing type.
-
-      Each reference includes:
-      - \`accessor\`: The exact path where this type is used in the schema tree
-      - \`description\`: The semantic description from that property definition
-
-      **Accessor Notation Guide**:
-      - \`TypeName.property\` - Used as an object property
-      - \`TypeName.property[]\` - Used as an array element
-      - \`TypeName.property{}\` - Used as a Record/dictionary value (additionalProperties)
-      - \`TypeName["special-key"]\` - Property name contains non-identifier characters
-
-      **How to Use This Information**:
-      1. The \`description\` field reveals the business purpose and semantic meaning
-      2. The \`accessor\` path shows the relationship and context within the API
-      3. Multiple references indicate different use cases the type must support
-      4. Description is captured at the property level, even if the $ref is nested
-         inside oneOf/anyOf/allOf structures (nullable, union types, etc.)
-
-      \`\`\`json
-      ${JSON.stringify(references, null, 2)}
-      \`\`\`
-
-      Analyze these references carefully to infer:
-      - What data this type should contain
-      - What business domain it belongs to
-      - What constraints or requirements it should satisfy
+        text: utils_1.StringUtil.trim `
+      ## Existing Schema References
+
+      The missing type **${props.typeName}** is referenced in the following locations
+      within existing schema definitions. Use these references to understand the context,
+      purpose, and expected structure of the missing type.
+
+      Each reference includes:
+      - \`accessor\`: The exact path where this type is used in the schema tree
+      - \`description\`: The semantic description from that property definition
+
+      **Accessor Notation Guide**:
+      - \`TypeName.property\` - Used as an object property
+      - \`TypeName.property[]\` - Used as an array element
+      - \`TypeName.property{}\` - Used as a Record/dictionary value (additionalProperties)
+      - \`TypeName["special-key"]\` - Property name contains non-identifier characters
+
+      **How to Use This Information**:
+      1. The \`description\` field reveals the business purpose and semantic meaning
+      2. The \`accessor\` path shows the relationship and context within the API
+      3. Multiple references indicate different use cases the type must support
+      4. Description is captured at the property level, even if the $ref is nested
+         inside oneOf/anyOf/allOf structures (nullable, union types, etc.)
+
+      \`\`\`json
+      ${JSON.stringify(references, null, 2)}
+      \`\`\`
+
+      Analyze these references carefully to infer:
+      - What data this type should contain
+      - What business domain it belongs to
+      - What constraints or requirements it should satisfy
     `,
     };
 };

package/lib/orchestrate/interface/histories/transformInterfaceSchemaRefineHistory.js

@@ -23,96 +23,96 @@ const transformInterfaceSchemaRefineHistory = (props) => {
                 type: "assistantMessage",
                 id: (0, uuid_1.v7)(),
                 created_at: new Date().toISOString(),
-                text: utils_1.StringUtil.trim `
-        ## API Design Instructions
-
-        The following API-specific instructions were extracted from
-        the user's requirements. These focus on API interface design aspects
-        relevant to the refinement task.
-
-        Follow these instructions when enriching schemas with documentation
-        and metadata.
-        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}
+                text: utils_1.StringUtil.trim `
+        ## API Design Instructions
+
+        The following API-specific instructions were extracted from
+        the user's requirements. These focus on API interface design aspects
+        relevant to the refinement task.
+
+        Follow these instructions when enriching schemas with documentation
+        and metadata.
+        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}
       `,
             },
             {
                 id: (0, uuid_1.v7)(),
                 type: "assistantMessage",
                 created_at: new Date().toISOString(),
-                text: utils_1.StringUtil.trim `
-          ## Operations (Filtered for Target Schema)
-
-          Here are the API operations that directly use the schema to refine.
-          These operations reference the target schema "${props.typeName}" via
-          requestBody.typeName or responseBody.typeName.
-
-          This FILTERED list helps you understand the exact usage context for
-          the schema you're enriching:
-
-          \`\`\`json
-          ${JSON.stringify(props.operations)}
-          \`\`\`
-
+                text: utils_1.StringUtil.trim `
+          ## Operations (Filtered for Target Schema)
+
+          Here are the API operations that directly use the schema to refine.
+          These operations reference the target schema "${props.typeName}" via
+          requestBody.typeName or responseBody.typeName.
+
+          This FILTERED list helps you understand the exact usage context for
+          the schema you're enriching:
+
+          \`\`\`json
+          ${JSON.stringify(props.operations)}
+          \`\`\`
+
           ${(0, transformInterfaceOperationParameterHistory_1.transformInterfaceOperationParameterHistory)({
                     typeName: props.typeName,
                     operations: props.operations,
-                })}
-
-          ## DTO type to refine
-
-          Here is the SPECIFIC schema that needs refinement for type "${props.typeName}":
-
-          \`\`\`json
-          ${JSON.stringify(props.schema)}
-          \`\`\`
-
-          Also, here is the list of properties currently defined in this schema,
-          so you have to enrich them one by one. Note that, only this schema needs
-          refinement. Other schemas in the complete schema set are provided for
-          reference only.
-
+                })}
+
+          ## DTO type to refine
+
+          Here is the SPECIFIC schema that needs refinement for type "${props.typeName}":
+
+          \`\`\`json
+          ${JSON.stringify(props.schema)}
+          \`\`\`
+
+          Also, here is the list of properties currently defined in this schema,
+          so you have to enrich them one by one. Note that, only this schema needs
+          refinement. Other schemas in the complete schema set are provided for
+          reference only.
+
           ${Object.keys(props.schema.properties)
                     .map((k) => `- ${k}`)
-                    .join("\n")}
-
+                    .join("\n")}
+
           ${transformDatabaseSchemaProperties({
                     everyModels,
                     model,
-                })}
+                })}
         `,
             },
         ],
-        userMessage: utils_1.StringUtil.trim `
-      Refine ${JSON.stringify(props.typeName)} schema by enriching each property
-      with \`databaseSchemaProperty\`, \`specification\`, and \`description\`.
-
-      **Object-level**: \`databaseSchema\` (nullable), \`specification\` (MANDATORY),
-      \`description\` (MANDATORY).
-
-      **Property-level**: Use \`depict\`, \`create\`, \`update\`, or \`erase\` for each
-      property in \`revises\`. DB properties not in this DTO go in \`excludes\`.
-
-      When \`databaseSchemaProperty\` or \`databaseSchema\` is \`null\`, the
-      \`specification\` becomes the ONLY source of truth for downstream agents.
-
-      You MUST provide a refinement for every single property without exception:
-      
+        userMessage: utils_1.StringUtil.trim `
+      Refine ${JSON.stringify(props.typeName)} schema by enriching each property
+      with \`databaseSchemaProperty\`, \`specification\`, and \`description\`.
+
+      **Object-level**: \`databaseSchema\` (nullable), \`specification\` (MANDATORY),
+      \`description\` (MANDATORY).
+
+      **Property-level**: Use \`depict\`, \`create\`, \`update\`, or \`erase\` for each
+      property in \`revises\`. DB properties not in this DTO go in \`excludes\`.
+
+      When \`databaseSchemaProperty\` or \`databaseSchema\` is \`null\`, the
+      \`specification\` becomes the ONLY source of truth for downstream agents.
+
+      You MUST provide a refinement for every single property without exception:
+      
       ${Object.keys(props.schema.properties)
             .map((k) => `- ${k}`)
-            .join("\n")}
-
+            .join("\n")}
+
       ${transformDatabaseSchemaProperties({
             everyModels,
             model,
-        })}
+        })}
     `,
     };
     return result;
@@ -135,21 +135,21 @@ function transformDatabaseSchemaProperties(props) {
         .filter((f) => f.relation.targetModel === props.model.name)
         .map((f) => f.relation.oppositeName))
         .filter((name) => name !== undefined);
-    return utils_1.StringUtil.trim `
-    ## Database Schema Properties for \`${props.model.name}\`
-
-    If you keep \`databaseSchema\` as \`${JSON.stringify(props.model.name)}\`,
-    every DB property below must be explicitly handled: either mapped to a DTO
-    property in \`revises\`, or declared in \`excludes\` with a reason.
-
-    **Columns** (scalar fields):
-    ${columns.map((c) => `- \`${c}\``).join("\n")}
-
-    **Belongs-to Relations** (FK → object):
-    ${belongsTo.length > 0 ? belongsTo.map((r) => `- \`${r}\``).join("\n") : "- (none)"}
-
-    **Has-many/Has-one Relations** (reverse side):
-    ${hasRelations.length > 0 ? hasRelations.map((r) => `- \`${r}\``).join("\n") : "- (none)"}
+    return utils_1.StringUtil.trim `
+    ## Database Schema Properties for \`${props.model.name}\`
+
+    If you keep \`databaseSchema\` as \`${JSON.stringify(props.model.name)}\`,
+    every DB property below must be explicitly handled: either mapped to a DTO
+    property in \`revises\`, or declared in \`excludes\` with a reason.
+
+    **Columns** (scalar fields):
+    ${columns.map((c) => `- \`${c}\``).join("\n")}
+
+    **Belongs-to Relations** (FK → object):
+    ${belongsTo.length > 0 ? belongsTo.map((r) => `- \`${r}\``).join("\n") : "- (none)"}
+
+    **Has-many/Has-one Relations** (reverse side):
+    ${hasRelations.length > 0 ? hasRelations.map((r) => `- \`${r}\``).join("\n") : "- (none)"}
   `;
 }
 //# sourceMappingURL=transformInterfaceSchemaRefineHistory.js.map

package/lib/orchestrate/interface/histories/transformInterfaceSchemaRenameHistory.js

@@ -18,37 +18,37 @@ const transformInterfaceSchemaRenameHistory = (props) => {
                 type: "assistantMessage",
                 id: (0, uuid_1.v7)(),
                 created_at: new Date().toISOString(),
-                text: utils_1.StringUtil.trim `
-          ## Database Table Names
-
-          Here is the complete list of table names from the database schema.
-          Use these as the source of truth for determining correct DTO type names.
-
-          Each table name should be converted to a DTO type name by:
-          1. Converting from snake_case to PascalCase
-          2. Preserving ALL words from the table name
-          3. Adding "I" prefix for interface types
-
-          Table Name | Expected DTO Type Name
-          -----------|------------------------
+                text: utils_1.StringUtil.trim `
+          ## Database Table Names
+
+          Here is the complete list of table names from the database schema.
+          Use these as the source of truth for determining correct DTO type names.
+
+          Each table name should be converted to a DTO type name by:
+          1. Converting from snake_case to PascalCase
+          2. Preserving ALL words from the table name
+          3. Adding "I" prefix for interface types
+
+          Table Name | Expected DTO Type Name
+          -----------|------------------------
           ${props.tableNames
                     .map((name) => [name, `I${utils_2.NamingConvention.pascal((0, pluralize_1.singular)(name))}`].join(" | "))
-                    .join("\n")}
-
-          ## Current DTO Type Names
-
-          Here is the list of existing DTO type names currently in the OpenAPI specification.
-          Analyze these to identify which ones violate the naming rules by omitting
-          intermediate words or service prefixes from their corresponding table names.
-
-          **Current Type Names:**
-          ${props.typeNames.map((name) => `- \`${name}\``).join("\n")}
-
-          ## Your Task
-
-          Compare the table names with the current type names to identify violations.
-          For each type name that incorrectly omits words from its table name,
-          provide a refactoring entry with the correct name that preserves all components.
+                    .join("\n")}
+
+          ## Current DTO Type Names
+
+          Here is the list of existing DTO type names currently in the OpenAPI specification.
+          Analyze these to identify which ones violate the naming rules by omitting
+          intermediate words or service prefixes from their corresponding table names.
+
+          **Current Type Names:**
+          ${props.typeNames.map((name) => `- \`${name}\``).join("\n")}
+
+          ## Your Task
+
+          Compare the table names with the current type names to identify violations.
+          For each type name that incorrectly omits words from its table name,
+          provide a refactoring entry with the correct name that preserves all components.
         `,
             },
         ],