@servicenow/sdk-build-core 4.4.1 → 4.6.0

package/src/now-config.ts

@@ -23,6 +23,192 @@ export const MODULE_RESOLUTION = {
     V2: '2.0.0',
 }
 
+// ============================================================================
+// Application Runtime Policy Schemas
+// ============================================================================
+
+/**
+ * Network Policy Schema
+ * Defines network access policies for the application (sys_arp_network_policy)
+ */
+const NetworkPolicySchema = z
+    .object({
+        $id: z
+            .string()
+            .regex(/^[0-9a-f]{32}$/, 'Must be a 32-character lowercase hexadecimal string')
+            .optional(),
+        active: z.boolean().default(true),
+        policyType: z.enum([
+            'csp_script_src',
+            'csp_connect_src',
+            'now_inbound_scoped',
+            'now_inbound_global',
+            'now_outbound',
+        ]),
+        status: z.enum(['requested', 'allowed', 'denied']),
+        host: z
+            .string()
+            .max(253)
+            .regex(
+                /^[a-z][a-z0-9+.-]*:\/\/[^/\s]+$/,
+                'Host must include scheme (e.g., https://api.example.com) and cannot contain paths'
+            )
+            .optional(),
+        scheme: z.enum(['http', 'https', 'ws', 'wss']).optional(),
+        path: z.array(z.string().max(1000)).max(100).optional(),
+        resource: z
+            .string()
+            .max(4000)
+            .regex(
+                /^[^\s,\n\r]+\.[^\s,\n\r]+(\.[^\s,\n\r]+)?$/,
+                'Resource must be "processor.subprocessor" or "processor.subprocessor.context" without spaces or commas'
+            )
+            .optional(),
+        shortDescription: z.string().max(1024).optional(),
+    })
+    .refine(
+        (data) => {
+            // Validate conditional field requirements based on policy type
+            const { policyType, host, scheme, path, resource } = data
+
+            switch (policyType) {
+                case 'csp_script_src':
+                case 'csp_connect_src':
+                    // Host required, resource must be empty
+                    if (!host || !host.trim()) {
+                        return false
+                    }
+                    if (resource && resource.trim()) {
+                        return false
+                    }
+                    break
+
+                case 'now_inbound_global':
+                    // Scheme required, host must be empty, path required, resource must be empty
+                    if (!scheme || !scheme.trim()) {
+                        return false
+                    }
+                    if (host && host.trim()) {
+                        return false
+                    }
+                    if (!path || path.length === 0) {
+                        return false
+                    }
+                    if (resource && resource.trim()) {
+                        return false
+                    }
+                    break
+
+                case 'now_outbound':
+                    // Host required, resource must be empty
+                    if (!host || !host.trim()) {
+                        return false
+                    }
+                    if (resource && resource.trim()) {
+                        return false
+                    }
+                    break
+
+                case 'now_inbound_scoped': {
+                    // Host must be empty, either path or resource (not both)
+                    if (host && host.trim()) {
+                        return false
+                    }
+                    const hasResource = resource && resource.trim()
+                    const hasPath = path && path.length > 0
+                    if (!hasResource && !hasPath) {
+                        return false
+                    }
+                    if (hasResource && hasPath) {
+                        return false
+                    }
+                    break
+                }
+            }
+
+            return true
+        },
+        {
+            message: 'Field requirements not met for policy type',
+        }
+    )
+
+export type NetworkPolicy = z.infer<typeof NetworkPolicySchema>
+
+/**
+ * Network Pillar Schema for Wildcard Policy
+ */
+const NetworkPillarSchema = z.object({
+    active: z.boolean().default(false),
+    networkWildcard: z
+        .array(
+            z.enum(['now_outbound', 'now_inbound_global', 'now_inbound_scoped', 'csp_connect_src', 'csp_script_src'])
+        )
+        .optional(),
+})
+
+/**
+ * Scripting Pillar Schema for Wildcard Policy
+ */
+const ScriptingPillarSchema = z.object({
+    active: z.boolean().default(false),
+    scriptingWildcard: z.array(z.enum(['sys_script_include', 'scriptable'])).optional(),
+})
+
+/**
+ * ARL Pillar Schema for Wildcard Policy
+ */
+const ArlPillarSchema = z.object({
+    active: z.boolean().default(false),
+    arlWildcard: z
+        .array(
+            z.enum(['scheduled_job_limit', 'event_handler', 'api_transaction_limit', 'interactive_transaction_limit'])
+        )
+        .optional(),
+})
+
+/**
+ * Wildcard Policy Schema
+ * Defines wildcard/exemption policies for the application (sys_arp_segment_policy)
+ * Only one per application scope
+ */
+const WildcardPolicySchema = z.object({
+    $id: z
+        .string()
+        .regex(/^[0-9a-f]{32}$/, 'Must be a 32-character lowercase hexadecimal string')
+        .optional(),
+    active: z.boolean().default(false),
+    shortDescription: z.string().max(1024).optional(),
+    record: z.boolean().default(false),
+    network: NetworkPillarSchema.optional(),
+    scripting: ScriptingPillarSchema.optional(),
+    arl: ArlPillarSchema.optional(),
+})
+
+export type WildcardPolicy = z.infer<typeof WildcardPolicySchema>
+
+/**
+ * Performance Policy Schema
+ * Defines resource limits for the application (sys_app_resource_limit_template)
+ * Only one per application scope
+ */
+const PerformancePolicySchema = z.object({
+    $id: z
+        .string()
+        .regex(/^[0-9a-f]{32}$/, 'Must be a 32-character lowercase hexadecimal string')
+        .optional(),
+    name: z.string().max(100),
+    scheduledJobLimit: z.number().int().min(1).max(100).optional(),
+    eventHandlerLimit: z.number().int().min(1).max(100).optional(),
+    apiTransactionLimit: z.number().int().min(1).max(100).optional(),
+    interactiveTransactionLimit: z.number().int().min(1).max(100).optional(),
+    mode: z.enum(['disabled', 'enforced', 'logOnly']).optional(),
+})
+
+export type PerformancePolicy = z.infer<typeof PerformancePolicySchema>
+
+// ============================================================================
+
 const NowConfigSchema = z
     .object({
         scope: z.string(),
@@ -62,11 +248,16 @@ const NowConfigSchema = z
         tsconfigPath: z.string().optional(),
         scripts: z.record(z.string(), z.string()).default({}),
         tableOutputFormat: z.enum(['bootstrap', 'component']).default('bootstrap'),
-        tableDefaultLanguage: z
+        defaultLanguage: z
             .string()
             .regex(/^[a-z]{2,3}(-[a-zA-Z0-9]{2,8})*$/)
             .default('en'),
 
+        tableDefaultLanguage: z // Deprecated — use defaultLanguage
+            .string()
+            .regex(/^[a-z]{2,3}(-[a-zA-Z0-9]{2,8})*$/)
+            .optional(),
+
         moduleDir: z.string().optional(), // Deprecated
         compileOutputDir: z.string().optional(), // Deprecated
         sourceDir: z.string().optional(), // Deprecated
@@ -105,6 +296,12 @@ const NowConfigSchema = z
         packageResolverVersion: z.string().optional(),
         type: z.enum(['configuration', 'package']).default('package'),
         taxonomy,
+
+        // Application Runtime Policy (ARP) fields
+        applicationRuntimePolicy: z.enum(['none', 'tracking', 'enforcing']).default('none'),
+        networkPolicies: z.array(NetworkPolicySchema).optional(),
+        wildcardPolicy: WildcardPolicySchema.optional(),
+        performancePolicy: PerformancePolicySchema.optional(),
     })
     .refine((data) => {
         if (!data.generatedDir.startsWith(data.fluentDir)) {
@@ -136,10 +333,15 @@ const NowConfigSchema = z
                 | 'installedAsDependency'
                 | 'scripts'
                 | 'tableOutputFormat'
+                | 'defaultLanguage'
                 | 'tableDefaultLanguage'
                 | 'packageResolverVersion'
                 | 'type'
                 | 'taxonomy'
+                | 'applicationRuntimePolicy'
+                | 'networkPolicies'
+                | 'wildcardPolicy'
+                | 'performancePolicy'
             >
         > = [
             'serverModulesDir',
@@ -373,6 +575,7 @@ const DEPRECATED_FIELDS: Record<string, DeprecatedField> = {
     entitiesDir: { replacedBy: 'fluentDir', transfer: true },
     transpiledSourceDir: { replacedBy: 'modulePaths' },
     sourceDir: {},
+    tableDefaultLanguage: { replacedBy: 'defaultLanguage', transfer: true },
 }
 
 function replaceDeprecatedFields(config: Record<string, unknown>, logger: Logger) {

package/src/plugins/index.ts

@@ -8,3 +8,4 @@ export * from './project'
 export * from './database'
 export * from './time'
 export * from './usage'
+export * from './post-install'

package/src/plugins/plugin.ts

@@ -24,11 +24,16 @@ export type Result<Value = unknown> =
     | {
           success: true
           value: Value
+          // Leftover nodes to be removed when a plugin chooses to claim ownership of a record by handling it in a different way
+          reclaimedRecords?: DeletedShape[]
       }
     | {
           success: 'partial'
           value: Value
+          // Records owned by a plugin (or descendants of that record) that a plugin has deferred to allow other plugins to handle
           unhandledRecords: Record[]
+          // Leftover nodes to be removed when a plugin chooses to claim ownership of a record by transforming it in a different way
+          reclaimedRecords?: DeletedShape[]
       }
 
 export type CommitResult = { success: boolean }
@@ -61,17 +66,8 @@ export type Relationship = {
      *             properties, where each is a tuple: [columnName, regexPattern]. The regex extracts
      *             values from the respective columns using capturing groups, and records are related
      *             if all captured groups match between parent and child
-     * - Function: Takes the parent and child records as arguments and returns a boolean to
-     *             indicate whether the records are related or not (WARNING: Do not use this
-     *             unless absolutely necessary as it can negatively impact performance and
-     *             cannot be serialized by the relationship resolver, requiring changes to
-     *             the REST API it invokes)
      */
-    via:
-        | string
-        | { [column: string]: string }
-        | ((parent: Record, child: Record) => boolean)
-        | { parent: [string, string]; child: [string, string] }[]
+    via: string | { [column: string]: string } | { parent: [string, string]; child: [string, string] }[]
 
     /**
      * When true, the relationship direction is reversed - the parent references the child
@@ -104,12 +100,6 @@ export type PluginApiDoc = {
      */
     apiName: string
 
-    /**
-     * Uses module-specifier path to the markdown documentation file for this API relative to the SDK root.
-     * For example, @servicenow/sdk/docs/BusinessRule/BusinessRule.md
-     */
-    docPath: string
-
     /**
      * Tags for categorizing and organizing the API documentation
      */
@@ -118,7 +108,6 @@ export type PluginApiDoc = {
 
 /**
  * Manifest structure for API documentation.
- * This is the opinionated format returned by getDocsMetadata().
  */
 export type DocsManifest = {
     [apiName: string]: {
@@ -142,7 +131,7 @@ export type PluginConfig<
      * Documentation for the APIs provided by this plugin. This is used to automatically
      * generate documentation that can be retrieved via the getDocsMetadata() method.
      */
-    docs?: PluginApiDoc[]
+    docs: PluginApiDoc[]
 
     /**
      * The TypeScript AST nodes this plugin handles. Plugins that do not introduce new
@@ -643,37 +632,38 @@ export class Plugin {
 
     /**
      * Get documentation metadata for APIs provided by this plugin.
-     * Returns a manifest object with raw (unresolved) documentation paths.
-     * Path resolution is handled by PluginRegistry.getDocsMetadata() using the isomorphic resolver.
      */
-    getDocsMetadata(): DocsManifest | undefined {
+    getDocsMetadata(): { [apiName: string]: { tags: string[] } } | undefined {
         if (!this.config.docs) {
             return undefined
         }
 
-        const manifest: DocsManifest = {}
+        const manifest: { [apiName: string]: { tags: string[] } } = {}
 
         for (const doc of this.config.docs) {
-            manifest[doc.apiName] = {
-                docPath: doc.docPath,
-                tags: doc.tags,
-            }
+            manifest[doc.apiName] = { tags: doc.tags }
         }
 
         return manifest
     }
 
     getDescendants(parent: Record, database: Database): Record[] {
+        return this.traverseDescendants(parent, database)
+    }
+
+    private traverseDescendants(parent: Record, database: Database, visited: Set<string> = new Set()): Record[] {
+        visited.add(parent.getId().getValue())
+
         const descendantRelationships = Object.entries(this.relationships[parent.getTable()] ?? {}).filter(
             ([, { descendant }]) => descendant
         )
-
         const descendants: Record[] = []
         const push = (children: Record | Record[] | undefined) => {
             for (const child of [children].flat()) {
-                if (child && parent !== child) {
+                if (child && !visited.has(child.getId().getValue())) {
+                    visited.add(child.getId().getValue())
                     descendants.push(child)
-                    descendants.push(...this.getDescendants(child, database))
+                    descendants.push(...this.traverseDescendants(child, database, visited))
                 }
             }
         }
@@ -689,8 +679,6 @@ export class Plugin {
                 } else {
                     push(database.query(childTable, { [via]: parent.toString().getValue() }))
                 }
-            } else if (typeof via === 'function') {
-                push(database.query(childTable).filter((child) => via(parent, child)))
             } else if (Array.isArray(via)) {
                 push(
                     database.query(childTable).filter((child) => {
@@ -699,16 +687,26 @@ export class Plugin {
                                 parent: [pCol, pReg],
                                 child: [cCol, cReg],
                             } = entry
-                            const parentValue = parent
-                                .get(pCol)
-                                .ifString()
-                                ?.asString(`Expected string value for column ${pCol} in regex-based via relationship`)
-                                .getValue()
-                            const childValue = child
-                                .get(cCol)
-                                .ifString()
-                                ?.asString(`Expected string value for column ${cCol} in regex-based via relationship`)
-                                .getValue()
+                            const parentValue =
+                                pCol === 'sys_id'
+                                    ? parent.getId().getValue()
+                                    : parent
+                                          .get(pCol)
+                                          .ifString()
+                                          ?.asString(
+                                              `Expected string value for column ${pCol} in regex-based via relationship`
+                                          )
+                                          .getValue()
+                            const childValue =
+                                cCol === 'sys_id'
+                                    ? child.getId().getValue()
+                                    : child
+                                          .get(cCol)
+                                          .ifString()
+                                          ?.asString(
+                                              `Expected string value for column ${cCol} in regex-based via relationship`
+                                          )
+                                          .getValue()
                             if (!parentValue || !childValue) {
                                 return false
                             }
@@ -959,6 +957,8 @@ export class Plugin {
     }): Promise<Result<Shape[]>> {
         let success = false
         const shapes: Shape[] = []
+        const unhandledRecords: Record[] = []
+        const unhandledRecordIds: Set<string> = new Set()
 
         for (const [table, { toShape }] of Object.entries(this.config.records ?? {})) {
             if (!toShape) {
@@ -1013,17 +1013,19 @@ export class Plugin {
                     descendants: nonDeletedDescendants,
                 })
 
-                // Track unhandled records to avoid marking them as handled
-                const unhandledRecords: Record[] = []
-                const unhandledRecordIds: string[] = []
-
                 if (result.success === 'partial') {
                     for (const unhandledRecord of result.unhandledRecords) {
                         unhandledRecords.push(unhandledRecord)
-                        unhandledRecordIds.push(unhandledRecord.getId().getValue())
+                        unhandledRecordIds.add(unhandledRecord.getId().getValue())
                     }
                 }
 
+                if (result.success !== false && result.reclaimedRecords && result.reclaimedRecords.length > 0) {
+                    // These records may have been deferred by the plugin in the past, but now they are handled.
+                    // The plugin is choosing to remove the old representation of these records
+                    shapes.push(...[result.reclaimedRecords].flat())
+                }
+
                 if (result.success) {
                     success = true
                     handledRecords.insert(record)
@@ -1031,21 +1033,32 @@ export class Plugin {
 
                     // Mark all descendants as handled
                     for (const descendant of [...deletedDescendants, ...nonDeletedDescendants]) {
-                        if (!unhandledRecordIds.includes(descendant.getId().getValue())) {
-                            handledRecords.insert(descendant)
+                        if (!unhandledRecordIds.has(descendant.getId().getValue())) {
+                            // This descendent was known to the plugin because it is not deleted, and handling was deferred
+                            // delete_multiple should also be marked 'handled'
+                            if (descendant.getAction() !== 'DELETE') {
+                                handledRecords.insert(descendant)
+                            } else if (
+                                !descendant.getCreator() ||
+                                !record.getCreator() ||
+                                descendant.getCreator()!.getName() === record.getCreator()!.getName()
+                            ) {
+                                // This descendant is handled by the same plugin that handled the root record
+                                handledRecords.insert(descendant)
+                            }
                         }
                     }
-                    context.logger.debug(
-                        `Plugin ${this.getName()} deferred handling of records: ${unhandledRecords.map((r) => r.getTable() + '_' + r.getId().getValue()).join(', ')}`
-                    )
-
-                    if (unhandledRecords.length > 0) {
-                        return { success: 'partial', value: shapes, unhandledRecords }
-                    }
                 }
             }
         }
 
+        if (unhandledRecords.length > 0) {
+            context.logger.debug(
+                `Plugin ${this.getName()} deferred handling of records: ${unhandledRecords.map((r) => r.getTable() + '_' + r.getId().getValue()).join(', ')}`
+            )
+            return { success: 'partial', value: shapes, unhandledRecords }
+        }
+
         return { success, value: shapes }
     }
 
@@ -1284,6 +1297,13 @@ export class Plugins {
         return this.plugins
     }
 
+    remove(name: string): void {
+        const index = this.plugins.findIndex((plugin) => plugin.getName() === name)
+        if (index !== -1) {
+            this.plugins.splice(index, 1)
+        }
+    }
+
     prepend(...plugins: Plugin[]): void {
         this.plugins.unshift(...plugins)
     }
@@ -1343,13 +1363,16 @@ export class Plugins {
         return false
     }
 
-    getDocsMetadata(): DocsManifest {
-        return this.plugins.reduce((aggregated, plugin) => {
-            const pluginManifest = plugin.getDocsMetadata()
-            if (pluginManifest) {
-                Object.assign(aggregated, pluginManifest)
-            }
-            return aggregated
-        }, {} as DocsManifest)
+    getDocsMetadata(): { [apiName: string]: { tags: string[] } } {
+        return this.plugins.reduce(
+            (aggregated, plugin) => {
+                const pluginManifest = plugin.getDocsMetadata()
+                if (pluginManifest) {
+                    Object.assign(aggregated, pluginManifest)
+                }
+                return aggregated
+            },
+            {} as { [apiName: string]: { tags: string[] } }
+        )
     }
 }

package/src/plugins/post-install.ts

@@ -0,0 +1,34 @@
+import type { Logger } from '../logger'
+
+export type PostInstallTask = {
+    /** Unique name for this task, used in logs and telemetry */
+    name: string
+
+    /** CLI flag name to skip this task (e.g., 'skipFlowActivation' maps to --skip-flow-activation) */
+    skipFlag: string
+
+    /** Human-readable description for the --skip flag help text */
+    skipFlagDescription: string
+
+    /**
+     * Controls which project type triggers this task.
+     * - `'app'` — only runs after installing a scoped app.
+     * - `'configuration'` — only runs after installing a configuration project.
+     * - `'both'` — runs after either install path.
+     */
+    runFor: 'app' | 'configuration' | 'both'
+
+    /** Execute the post-install task */
+    run(context: PostInstallContext): Promise<void>
+}
+
+/** Minimal interface for making authenticated requests to a ServiceNow instance */
+export type InstanceClient = {
+    fetch(path: string, init?: RequestInit, params?: URLSearchParams): Promise<Response>
+}
+
+export type PostInstallContext = {
+    instanceClient?: InstanceClient
+    logger: Logger
+    config: { scopeId: string; scope: string; [key: string]: unknown }
+}

package/src/plugins/shape.ts

@@ -1170,7 +1170,10 @@ export class ObjectShape extends Shape<globalThis.Record<string, unknown>> {
     }
 
     static quotePropertyNameIfNeeded(name: string): string {
-        return name === '' || /[^\w$]/.test(name) ? `'${name}'` : name
+        // Valid JS identifier (e.g. short_description, $id) — no quotes needed
+        // Pure numeric literal without leading zeros (e.g. 0, 100, 1.5) — valid as object key without quotes
+        // Everything else (empty string, hyphens, digit-leading non-numeric chars, octal-like 007) — must be quoted
+        return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) || /^(0|[1-9]\d*)(\.\d+)?$/.test(name) ? name : `'${name}'`
     }
 }
 

package/src/taxonomy.ts

@@ -103,9 +103,51 @@ const TableNames = {
     SYS_SG_PARAMETER_SCREEN: 'sys_sg_parameter_screen',
     SYS_SG_APPLET_LAUNCHER: 'sys_sg_applet_launcher',
 
+    // AIAF tables
+    SN_AI_AGENT: 'sn_aia_agent',
+    SN_AIA_LTM_CATEGORY_MAPPING: 'sn_aia_ltm_category_mapping',
+    SN_AI_AGENT_CONFIG: 'sn_aia_agent_config',
+    SN_AI_AGENT_VERSION: 'sn_aia_version',
+    SN_AI_AGENT_TOOL: 'sn_aia_tool',
+    SN_AI_AGENT_TOOL_M2M: 'sn_aia_agent_tool_m2m',
+    SYS_AGENT_ACCESS_ROLE_CONFIG: 'sys_agent_access_role_configuration',
+    SN_AIA_TRIGGER_CONFIG: 'sn_aia_trigger_configuration',
+    SN_AIA_TRIGGER_MAPPING: 'sn_aia_trigger_agent_usecase_m2m',
+    SN_AIA_USECASE: 'sn_aia_usecase',
+    SN_AIA_TEAM_MEMBER: 'sn_aia_team_member',
+    SN_AIA_TEAM: 'sn_aia_team',
+    SN_AIA_USECASE_CONFIG: 'sn_aia_usecase_config_override',
+
     // Natural Language Understanding tables
     SYS_NLU_MODEL: 'sys_nlu_model',
 
+    // Now Assist tables
+    SN_NOWASSIST_SKILL_CONFIG: 'sn_nowassist_skill_config',
+    SN_NOWASSIST_SKILL_CONFIG_STATUS: 'sn_nowassist_skill_config_status',
+    SN_NOWASSIST_SKILL_CONFIG_VAR_SET: 'sn_nowassist_skill_config_var_set',
+    SN_NOWASSIST_SKILL_CONFIG_APPLICABILITY: 'sn_nowassist_skill_config_applicability',
+    SN_NOWASSIST_SKILL_CONFIG_UI: 'sn_ns_skill_config_ui',
+    SYS_GENERATIVE_AI_CONFIG: 'sys_generative_ai_config',
+    SYS_GENERATIVE_AI_PROMPT_CONFIG: 'sys_generative_ai_prompt_config',
+    SYS_GENERATIVE_AI_VALIDATOR: 'sys_generative_ai_validator',
+    SYS_GENERATIVE_AI_REQUEST_VALIDATOR: 'sys_generative_ai_request_validator',
+    SYS_GENERATIVE_AI_RESPONSE_VALIDATOR: 'sys_generative_ai_response_validator',
+    SYS_GEN_AI_SKILL: 'sys_gen_ai_skill',
+    SYS_GEN_AI_SKILL_APPLICABILITY: 'sys_gen_ai_skill_applicability',
+    SYS_GEN_AI_SKILL_CONFIG: 'sys_gen_ai_skill_config',
+    SYS_GEN_AI_FEATURE_MAPPING: 'sys_gen_ai_feature_mapping',
+    SYS_GEN_AI_STRATEGY_MAPPING: 'sys_gen_ai_strategy_mapping',
+    SYS_ONE_EXTEND_CAPABILITY: 'sys_one_extend_capability',
+    SYS_ONE_EXTEND_CAPABILITY_DEFINITION: 'sys_one_extend_capability_definition',
+    SYS_ONE_EXTEND_DEFINITION_ATTRIBUTE: 'sys_one_extend_definition_attribute',
+    SYS_ONE_EXTEND_DEFINITION_CONFIG: 'sys_one_extend_definition_config',
+    SYS_ONE_EXTEND_RESOURCE_EDGE: 'sys_one_extend_resource_edge',
+    SYS_ONE_EXTEND_RESOURCE_MAPPING: 'sys_one_extend_resource_mapping',
+    SYS_ONE_EXTEND_RESOURCE_ATTRIBUTE_MAPPING: 'sys_one_extend_resource_attribute_mapping',
+    SYS_ONE_EXTEND_RESOURCE_PARAM_VALUE: 'sys_one_extend_resource_param_value',
+    SYS_ONE_EXTEND_EVAL_STRATEGY: 'sys_one_extend_eval_strategy',
+    SYS_ONE_EXTEND_EVAL_STRATEGY_METRIC: 'sys_one_extend_eval_strategy_metric',
+    SYS_ONE_EXTEND_EVAL_ATTRIBUTE: 'sys_one_extend_eval_attribute',
     // Properties tables
     SYS_PROPERTIES: 'sys_properties',
     SYS_PROPERTIES_CATEGORY: 'sys_properties_category',
@@ -295,6 +337,17 @@ const taxonomyMapping = z
         // Natural Language Understanding tables
         [TableNames.SYS_NLU_MODEL]: taxonomyItem.default('natural-language-understanding/nlu-model'),
 
+        // Now Assist - Skill Config
+        [TableNames.SN_NOWASSIST_SKILL_CONFIG]: taxonomyItem.default('now-assist/skill'),
+        [TableNames.SN_NOWASSIST_SKILL_CONFIG_STATUS]: taxonomyItem.default('now-assist/skill-config'),
+        [TableNames.SN_NOWASSIST_SKILL_CONFIG_VAR_SET]: taxonomyItem.default('now-assist/skill-config'),
+        [TableNames.SN_NOWASSIST_SKILL_CONFIG_APPLICABILITY]: taxonomyItem.default('now-assist/skill-config'),
+        [TableNames.SN_NOWASSIST_SKILL_CONFIG_UI]: taxonomyItem.default('now-assist/skill-config'),
+
+        // AI Agent and Agentic Workflow
+        [TableNames.SN_AI_AGENT]: taxonomyItem.default('ai-agent/agent'),
+        [TableNames.SN_AIA_USECASE]: taxonomyItem.default('ai-agent/agentic-workflow'),
+
         // Properties tables
         [TableNames.SYS_PROPERTIES]: taxonomyItem.default('properties/system-property'),
         [TableNames.SYS_PROPERTIES_CATEGORY]: taxonomyItem.default('properties/system-property-category'),