@azure-tools/typespec-ts 0.55.0-dev.9 → 0.55.1

package/src/modular/emit-models-options.ts

@@ -4,9 +4,9 @@ import { ModularEmitterOptions } from "./interfaces.js";
 
 import { SdkClientType, SdkServiceOperation } from "@azure-tools/typespec-client-generator-core";
 import { useContext } from "../context-manager.js";
-import { NameType, normalizeName } from "../rlc-common/index.js";
-import { getModularClientOptions } from "../utils/client-utils.js";
+import { getClientModuleInfo } from "../utils/client-utils.js";
 import { SdkContext } from "../utils/interfaces.js";
+import { NameType, normalizeName } from "../utils/name-utils.js";
 import { getMethodHierarchiesMap } from "../utils/operation-util.js";
 import { buildOperationOptions } from "./build-operations.js";
 
@@ -20,7 +20,7 @@ export function buildApiOptions(
   const project = useContext("outputProject");
   const [_, client] = clientMap;
   const modelOptionsFiles = [];
-  const { subfolder } = getModularClientOptions(clientMap);
+  const { subfolder } = getClientModuleInfo(clientMap);
   const methodMap = getMethodHierarchiesMap(context, client);
   for (const [prefixKey, operations] of methodMap) {
     const prefixes = prefixKey.split("/");

package/src/modular/emit-models.ts

@@ -28,7 +28,6 @@ import {
   StructureKind,
   TypeAliasDeclarationStructure,
 } from "ts-morph";
-import { fixLeadingNumber, NameType, normalizeName } from "../rlc-common/index.js";
 // import { isKey } from "@typespec/compiler";
 import {
   getExternalModel,
@@ -44,13 +43,15 @@ import {
   emitQueue,
   flattenPropertyModelMap,
   getAllOperationsFromClient,
-  pagedModelsUsedInNonPagingOps,
+  pagedModelsKeptPublic,
 } from "../framework/hooks/sdk-types.js";
 import { refkey } from "../framework/refkey.js";
+import { beginSourceFileBatch, flushSourceFileBatch } from "../framework/source-file-batch.js";
 import { reportDiagnostic } from "../lib.js";
 import { getClientHierarchyMap } from "../utils/client-utils.js";
 import { SdkContext } from "../utils/interfaces.js";
 import { isAzureCoreErrorType } from "../utils/model-utils.js";
+import { fixLeadingNumber, NameType, normalizeName } from "../utils/name-utils.js";
 import { getMethodHierarchiesMap } from "../utils/operation-util.js";
 import { getHeaderClientOptions } from "./helpers/client-option-helpers.js";
 import {
@@ -117,32 +118,37 @@ export function emitTypes(context: SdkContext, { sourceRoot }: { sourceRoot: str
 
   let sourceFile;
 
-  for (const type of emitQueue) {
-    if (!isGenerableType(type)) {
-      continue;
-    }
+  beginSourceFileBatch();
+  try {
+    for (const type of emitQueue) {
+      if (!isGenerableType(type)) {
+        continue;
+      }
 
-    const namespaces = getModelNamespaces(context, type);
-    const filepath = getModelsPath(sourceRoot, namespaces);
-    sourceFile = outputProject.getSourceFile(filepath);
-    if (!sourceFile) {
-      sourceFile = outputProject.createSourceFile(filepath);
-      sourceFile.addStatements(`/**
+      const namespaces = getModelNamespaces(context, type);
+      const filepath = getModelsPath(sourceRoot, namespaces);
+      sourceFile = outputProject.getSourceFile(filepath);
+      if (!sourceFile) {
+        sourceFile = outputProject.createSourceFile(filepath);
+        sourceFile.addStatements(`/*
 * This file contains only generated model types and their (de)serializers.
 * Disable the following rules for internal models with '_' prefix and deserializers which require 'any' for raw JSON input.
 */
 /* eslint-disable @typescript-eslint/naming-convention */
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */`);
+      }
+      emitType(context, type, sourceFile);
     }
-    emitType(context, type, sourceFile);
-  }
 
-  // Emit serialization/deserialization functions for flattened properties
-  for (const [property, _] of flattenPropertyModelMap) {
-    const namespaces = getModelNamespaces(context, property.type);
-    const filepath = getModelsPath(sourceRoot, namespaces);
-    sourceFile = outputProject.getSourceFile(filepath);
-    addSerializationFunctions(context, property, sourceFile!);
+    // Emit serialization/deserialization functions for flattened properties
+    for (const [property, _] of flattenPropertyModelMap) {
+      const namespaces = getModelNamespaces(context, property.type);
+      const filepath = getModelsPath(sourceRoot, namespaces);
+      sourceFile = outputProject.getSourceFile(filepath);
+      addSerializationFunctions(context, property, sourceFile!);
+    }
+  } finally {
+    flushSourceFileBatch();
   }
 
   const modelFiles = outputProject.getSourceFiles(sourceRoot + "/models/**/*.ts");
@@ -245,7 +251,7 @@ function emitType(context: SdkContext, type: SdkType, sourceFile: SourceFile) {
     }
     const apiVersionEnumOnly = type.usage === UsageFlags.ApiVersionEnum;
     // Skip known api version enums for multi-service scenarios as users are not allowed to set api versions
-    if (apiVersionEnumOnly && context.rlcOptions?.isMultiService) {
+    if (apiVersionEnumOnly && context.emitterOptions?.isMultiService) {
       return;
     }
     const inputUsage = (type.usage & UsageFlags.Input) === UsageFlags.Input;
@@ -290,7 +296,7 @@ function emitType(context: SdkContext, type: SdkType, sourceFile: SourceFile) {
 
 export function getApiVersionEnum(context: SdkContext) {
   // Skip api version enum for multi-service scenarios since each service may have different versions
-  if (context.rlcOptions?.isMultiService) {
+  if (context.emitterOptions?.isMultiService) {
     return;
   }
   const apiVersionEnum = context.sdkPackage.enums.find(
@@ -325,7 +331,7 @@ export function getModelNamespaces(context: SdkContext, model: SdkType): string[
     }
     const segments = model.namespace.split(".");
     // Keep full namespace segments if multiple services are present because there isn't a root namespace to trim
-    if (context.rlcOptions?.isMultiService) {
+    if (context.emitterOptions?.isMultiService) {
       return segments;
     }
 
@@ -603,7 +609,7 @@ function emitEnumMember(
 ): EnumMemberStructure {
   const shouldNormalizeName = !member.name.startsWith("$DO_NOT_NORMALIZE$");
   const enumTypeName = normalizeName(member.enumType.name, NameType.Interface, true);
-  let normalizedMemberName = context.rlcOptions?.ignoreEnumMemberNameNormalize
+  let normalizedMemberName = context.emitterOptions?.ignoreEnumMemberNameNormalize
     ? fixLeadingNumber(member.name, NameType.EnumMemberName) // need to fix the leading number also for enum member
     : normalizeName(member.name, NameType.EnumMemberName, true);
   // If the member name starts with _ due to a leading digit (not because the original has _),
@@ -744,7 +750,7 @@ function addExtendedDictInfo(
   const additionalPropertiesType = model.additionalProperties
     ? getTypeExpression(context, model.additionalProperties)
     : undefined;
-  if (context.rlcOptions?.compatibilityMode) {
+  if (context.emitterOptions?.compatibilityMode) {
     const ancestors = getAllAncestors(model);
     const properties = getAllProperties(context, model, ancestors);
     let anyType: boolean;
@@ -839,10 +845,9 @@ export function normalizeModelName(
       unionSuffix = "Union";
     }
   }
-  const namespacePrefix = context.rlcOptions?.enableModelNamespace ? segments.join("") : "";
+  const namespacePrefix = context.emitterOptions?.enableModelNamespace ? segments.join("") : "";
   const internalModelPrefix =
-    (isPagedResultModel(context, type) && !pagedModelsUsedInNonPagingOps.has(type)) ||
-    type.isGeneratedName
+    (isPagedResultModel(context, type) && !pagedModelsKeptPublic.has(type)) || type.isGeneratedName
       ? "_"
       : "";
   return `${internalModelPrefix}${normalizeName(namespacePrefix + type.name, nameType, true)}${unionSuffix}`;
@@ -884,7 +889,7 @@ function buildModelProperty(
 ): PropertySignatureStructure {
   const normalizedPropName = normalizeModelPropertyName(context, property);
   if (
-    !context.rlcOptions?.ignorePropertyNameNormalize &&
+    !context.emitterOptions?.ignorePropertyNameNormalize &&
     normalizedPropName !== `"${property.name}"`
   ) {
     reportDiagnostic(context.program, {
@@ -932,7 +937,7 @@ export function visitPackageTypes(context: SdkContext) {
   const { sdkPackage } = context;
   emitQueue.clear();
   flattenPropertyModelMap.clear();
-  pagedModelsUsedInNonPagingOps.clear();
+  pagedModelsKeptPublic.clear();
   // Add all models in the package to the emit queue
   for (const model of sdkPackage.models) {
     visitType(context, model);
@@ -1015,7 +1020,19 @@ function trackPagedModelInNonPagingMethod(
   if (method.kind !== "basic" && method.kind !== "lro") return;
   const respType = method.response.type;
   if (respType && isPagedResultModel(context, respType)) {
-    pagedModelsUsedInNonPagingOps.add(respType);
+    pagedModelsKeptPublic.add(respType);
+  }
+}
+
+/**
+ * If a paged result model is used as a model property type, mark it so that
+ * normalizeModelName keeps it public (no "_" prefix).
+ */
+function trackPagedModelUsedAsProperty(context: SdkContext, type: SdkType): void {
+  // Unwrap array types to check the element type
+  const resolved = type.kind === "array" ? type.valueType : type;
+  if (resolved && isPagedResultModel(context, resolved)) {
+    pagedModelsKeptPublic.add(resolved);
   }
 }
 
@@ -1044,6 +1061,10 @@ function visitType(context: SdkContext, type: SdkType | undefined) {
       if (property.flatten && property.type.kind === "model") {
         flattenPropertyModelMap.set(property, type);
       }
+      // If a paged result model is used as a model property (not as a paging
+      // operation response), it must stay public (no "_" prefix) because users
+      // interact with it directly through the property.
+      trackPagedModelUsedAsProperty(context, property.type);
     }
     if (type.discriminatedSubtypes) {
       for (const subType of Object.values(type.discriminatedSubtypes)) {

package/src/modular/emit-samples.ts

@@ -14,10 +14,10 @@ import { useContext } from "../context-manager.js";
 import { resolveReference } from "../framework/reference.js";
 import { reportDiagnostic } from "../index.js";
 import { AzureIdentityDependencies } from "../modular/external-dependencies.js";
-import { NameType, normalizeName } from "../rlc-common/index.js";
-import { getSubscriptionId } from "../transform/transfrom-rlc-options.js";
+import { getSubscriptionId } from "../transform/transform-client-options.js";
 import { hasKeyCredential, hasTokenCredential } from "../utils/credential-utils.js";
 import { SdkContext } from "../utils/interfaces.js";
+import { NameType, normalizeName } from "../utils/name-utils.js";
 import {
   getMethodHierarchiesMap,
   isTenantLevelOperation,
@@ -115,9 +115,9 @@ function emitMethodSamples(
   });
   const exampleFunctions = [];
   // TODO: remove hard-coded for package
-  if (dpgContext.rlcOptions?.packageDetails?.name) {
+  if (dpgContext.emitterOptions?.packageDetails?.name) {
     sourceFile.addImportDeclaration({
-      moduleSpecifier: dpgContext.rlcOptions?.packageDetails?.name,
+      moduleSpecifier: dpgContext.emitterOptions?.packageDetails?.name,
       namedImports: [getClassicalClientName(options.topLevelClient)],
     });
   }
@@ -316,12 +316,36 @@ function prepareExampleParameters(
 
   let subscriptionIdValue = `"00000000-0000-0000-0000-000000000000"`;
   let isSubscriptionIdAdded = false;
-  // required parameters
+
+  // Map each HTTP parameter to its method parameter via `methodParameterSegments`
+  // and place its example value at that path, yielding one argument per method
+  // parameter regardless of flat, nested, or grouped shape. Client- and
+  // body-carried roots are emitted by their own sections and skipped here.
+  const bodyParam = method.operation.bodyParam;
+  let bodyRootName: string | undefined;
+  if (
+    bodyParam &&
+    !isSpreadBodyParameter(bodyParam) &&
+    bodyParam.methodParameterSegments.length === 1 &&
+    bodyParam.methodParameterSegments[0] !== undefined &&
+    bodyParam.methodParameterSegments[0].length >= 1
+  ) {
+    bodyRootName = bodyParam.methodParameterSegments[0][0]!.name;
+  }
+
+  const methodArguments = new Map<
+    string,
+    { name: string; isOptional: boolean; value: ValueTreeNode | string }
+  >();
   for (const param of method.operation.parameters) {
-    if (param.optional === true || param.type.kind === "constant" || param.clientDefaultValue) {
+    if (param.type.kind === "constant" || param.clientDefaultValue) {
       continue;
     }
-
+    const path = param.methodParameterSegments[0];
+    if (path === undefined || path.length === 0) {
+      continue;
+    }
+    const root = path[0]!;
     const exampleValue = parameterMap[param.serializedName];
 
     // Handle subscriptionId parameter separately for ARM clients
@@ -343,28 +367,27 @@ function prepareExampleParameters(
       continue;
     }
 
+    // Roots emitted by the client and body sections.
+    if (root.onClient || (bodyRootName !== undefined && root.name === bodyRootName)) {
+      continue;
+    }
+
     if (!exampleValue || !exampleValue.value) {
       // report diagnostic if required parameter is missing
-      reportDiagnostic(dpgContext.program, {
-        code: "required-sample-parameter",
-        format: {
-          exampleName: method.oriName ?? method.name,
-          paramName: param.name,
-        },
-        target: NoTarget,
-      });
+      if (path.length === 1 && !param.optional) {
+        reportDiagnostic(dpgContext.program, {
+          code: "required-sample-parameter",
+          format: {
+            exampleName: method.oriName ?? method.name,
+            paramName: param.name,
+          },
+          target: NoTarget,
+        });
+      }
       continue;
     }
 
-    result.push(
-      prepareExampleValue(
-        dpgContext,
-        exampleValue.parameter.name,
-        exampleValue.value,
-        param.optional,
-        param.onClient,
-      ),
-    );
+    placeMethodArgument(methodArguments, path, getParameterValue(dpgContext, exampleValue.value));
   }
 
   // If client-level subscriptionId is needed on the client for this method, then add it
@@ -381,7 +404,6 @@ function prepareExampleParameters(
   }
 
   // required/optional body parameters
-  const bodyParam = method.operation.bodyParam;
   const bodySerializeName = bodyParam?.serializedName;
   const bodyExample = parameterMap[bodySerializeName ?? ""];
   if (bodyParam && bodyExample && bodyExample.value) {
@@ -441,28 +463,87 @@ function prepareExampleParameters(
       }
     }
   }
-  // optional parameters
-  method.operation.parameters
-    .filter(
-      (param) =>
-        param.optional === true && parameterMap[param.serializedName] && !param.clientDefaultValue,
-    )
-    .map((param) => parameterMap[param.serializedName]!)
-    .forEach((param) => {
-      result.push(
-        prepareExampleValue(
-          dpgContext,
-          param.parameter.name,
-          param.value,
-          true,
-          param.parameter.onClient,
-        ),
-      );
+  // Emit one argument per top-level method parameter. A normal parameter carries
+  // a scalar value; a parameter with nested leaves carries an object literal.
+  for (const arg of methodArguments.values()) {
+    result.push({
+      name: normalizeName(arg.name, NameType.Parameter, true),
+      value: serializeNestedValue(arg.value),
+      isOptional: arg.isOptional,
+      onClient: false,
     });
+  }
 
   return result;
 }
 
+/** A nested value tree: leaves are TypeScript value expressions, interior nodes are objects. */
+interface ValueTreeNode {
+  [key: string]: ValueTreeNode | string;
+}
+
+/**
+ * Records `leaf` for the method parameter addressed by `path`. `path[0]` is the
+ * top-level method parameter (the argument key); a single-segment path stores a
+ * scalar, a longer path stores the leaf inside a nested object merged with
+ * sibling leaves sharing the same root.
+ */
+function placeMethodArgument(
+  methodArguments: Map<
+    string,
+    { name: string; isOptional: boolean; value: ValueTreeNode | string }
+  >,
+  path: readonly { name: string; optional?: boolean }[],
+  leaf: string,
+): void {
+  const root = path[0]!;
+  let arg = methodArguments.get(root.name);
+  if (!arg) {
+    arg = { name: root.name, isOptional: Boolean(root.optional), value: {} };
+    methodArguments.set(root.name, arg);
+  }
+  if (path.length === 1) {
+    arg.value = leaf;
+    return;
+  }
+  if (typeof arg.value !== "object") {
+    arg.value = {};
+  }
+  setNestedValue(arg.value, path.slice(1), leaf);
+}
+
+/** Places `leaf` at `path` (segments after the root), creating intermediate objects as needed. */
+function setNestedValue(
+  root: ValueTreeNode,
+  path: readonly { name: string }[],
+  leaf: string,
+): void {
+  let node = root;
+  for (let i = 0; i < path.length; i++) {
+    const key = normalizeName(path[i]!.name, NameType.Property, true);
+    if (i === path.length - 1) {
+      node[key] = leaf;
+    } else {
+      const existing = node[key];
+      if (typeof existing !== "object" || existing === null) {
+        node[key] = {};
+      }
+      node = node[key] as ValueTreeNode;
+    }
+  }
+}
+
+/** Serializes a {@link ValueTreeNode} into a TypeScript object literal string. */
+function serializeNestedValue(node: ValueTreeNode | string): string {
+  if (typeof node === "string") {
+    return node;
+  }
+  const entries = Object.entries(node).map(
+    ([key, value]) => `${key}: ${serializeNestedValue(value)}`,
+  );
+  return `{ ${entries.join(", ")} }`;
+}
+
 function getCredentialExampleValue(
   _dpgContext: SdkContext,
   initialization: SdkClientInitializationType,
@@ -525,7 +606,7 @@ function getParameterValue(
       retValue = `${JSON.stringify(value.value)}`;
       break;
     case "null": {
-      const ignoreNullableOnOptional = context.rlcOptions?.ignoreNullableOnOptional ?? false;
+      const ignoreNullableOnOptional = context.emitterOptions?.ignoreNullableOnOptional ?? false;
       if (ignoreNullableOnOptional) {
         // When ignore-nullable-on-optional is true, the TypeScript type won't include
         // | null for optional properties, so we convert null to a type-appropriate default

package/src/modular/emit-tests.ts

@@ -1,8 +1,8 @@
 import { type CompilerHost, joinPaths } from "@typespec/compiler";
 import { SourceFile } from "ts-morph";
 import { resolveReference } from "../framework/reference.js";
-import { NameType, normalizeName } from "../rlc-common/index.js";
 import { SdkContext } from "../utils/interfaces.js";
+import { NameType, normalizeName } from "../utils/name-utils.js";
 import { ServiceOperation } from "../utils/operation-util.js";
 import { AzureTestDependencies } from "./external-dependencies.js";
 import {

package/src/modular/helpers/classical-operation-helpers.ts

@@ -10,9 +10,9 @@ import {
 import { addDeclaration } from "../../framework/declaration.js";
 import { resolveReference } from "../../framework/reference.js";
 import { refkey } from "../../framework/refkey.js";
-import { NameType, normalizeName } from "../../rlc-common/index.js";
-import { getModularClientOptions } from "../../utils/client-utils.js";
+import { getClientModuleInfo } from "../../utils/client-utils.js";
 import { SdkContext } from "../../utils/interfaces.js";
+import { NameType, normalizeName } from "../../utils/name-utils.js";
 import { ServiceOperation } from "../../utils/operation-util.js";
 import { AzurePollingDependencies } from "../external-dependencies.js";
 import { PagingHelpers, SimplePollerHelpers } from "../static-helpers-metadata.js";
@@ -55,18 +55,18 @@ export function getClassicalOperation(
 ) {
   const prefixes = operationGroup[0];
   const operations = operationGroup[1];
-  const { rlcClientName } = getModularClientOptions(clientMap);
+  const { clientName } = getClientModuleInfo(clientMap);
   const hasClientContextImport = classicFile.getImportDeclarations().filter((i) => {
     return (
       i.getModuleSpecifierValue() ===
-      `${"../".repeat(layer + 2)}api/${normalizeName(rlcClientName, NameType.File)}.js`
+      `${"../".repeat(layer + 2)}api/${normalizeName(clientName, NameType.File)}.js`
     );
   });
   if (!hasClientContextImport || hasClientContextImport.length === 0) {
     classicFile.addImportDeclaration({
-      namedImports: [rlcClientName],
+      namedImports: [clientName],
       moduleSpecifier: `${"../".repeat(layer + 2)}api/${normalizeName(
-        rlcClientName,
+        clientName,
         NameType.File,
       )}.js`,
     });
@@ -78,7 +78,7 @@ export function getClassicalOperation(
   >();
   const operationDeclarations: OptionalKind<FunctionDeclarationStructure>[] = operations.map(
     (operation) => {
-      const declaration = getOperationFunction(dpgContext, [prefixes, operation], rlcClientName);
+      const declaration = getOperationFunction(dpgContext, [prefixes, operation], clientName);
       operationDeclarationMap.set(declaration, {
         declaration,
         oriName: operation.oriName,
@@ -141,7 +141,7 @@ export function getClassicalOperation(
       });
       // add LRO helper methods if applicable
       if (
-        dpgContext.rlcOptions?.compatibilityLro &&
+        dpgContext.emitterOptions?.compatibilityLro &&
         (operationInfo?.isLro || operationInfo?.isLroPaging)
       ) {
         const operationStateReference = resolveReference(AzurePollingDependencies.OperationState);
@@ -207,7 +207,7 @@ export function getClassicalOperation(
       parameters: [
         {
           name: "context",
-          type: rlcClientName,
+          type: clientName,
         },
       ],
       statements: `return {
@@ -237,7 +237,7 @@ export function getClassicalOperation(
             ];
             // add LRO helper methods if applicable
             if (
-              dpgContext.rlcOptions?.compatibilityLro &&
+              dpgContext.emitterOptions?.compatibilityLro &&
               (operationInfo?.isLro || operationInfo?.isLroPaging)
             ) {
               const getSimplePollerReference = resolveReference(
@@ -336,7 +336,7 @@ export function getClassicalOperation(
       parameters: [
         {
           name: "context",
-          type: rlcClientName,
+          type: clientName,
         },
       ],
       returnType: resolveReference(refkey(interfaceName, layer, "classicOperations")),

package/src/modular/helpers/client-helpers.ts

@@ -10,8 +10,8 @@ import { OptionalKind, ParameterDeclarationStructure, StatementedNode } from "ts
 import { ModularEmitterOptions } from "../interfaces.js";
 
 import { resolveReference } from "../../framework/reference.js";
-import { NameType, normalizeName } from "../../rlc-common/index.js";
 import { SdkContext } from "../../utils/interfaces.js";
+import { NameType, normalizeName } from "../../utils/name-utils.js";
 import { CloudSettingHelpers } from "../static-helpers-metadata.js";
 import { getTypeExpression } from "../type-expressions/get-type-expression.js";
 import { getClassicalClientName } from "./naming-helpers.js";
@@ -87,10 +87,10 @@ export function getClientParameters(
   const armSpecific = (p: SdkParameter) => !(p.kind === "endpoint" && dpgContext.arm);
   // Skip apiVersion parameter when it's multi-service (each service has its own default apiVersion)
   const skipApiVersionOnMultiService = (p: SdkParameter) =>
-    !(dpgContext.rlcOptions?.isMultiService && p.isApiVersionParam);
+    !(dpgContext.emitterOptions?.isMultiService && p.isApiVersionParam);
   const filters = [
     options.requiredOnly ? isRequired : undefined,
-    dpgContext.rlcOptions?.addCredentials === false ? skipCredentials : undefined,
+    dpgContext.emitterOptions?.addCredentials === false ? skipCredentials : undefined,
     options.optionalOnly ? isOptional : undefined,
     options.onClientOnly ? skipMethodParam : undefined,
     options.skipArmSpecific ? undefined : armSpecific,
@@ -241,7 +241,7 @@ export function buildGetClientOptionsParam(
   endpointParam: string,
   apiVersionParamName?: string,
 ): string {
-  const userAgentOptions = buildUserAgentOptions(context, emitterOptions, "azsdk-js-api");
+  const userAgentOptions = buildUserAgentOptions(context, emitterOptions);
   const loggingOptions = buildLoggingOptions();
   const credentials = buildCredentials(emitterOptions, endpointParam);
 
@@ -313,10 +313,14 @@ function buildLoggingOptions(): string | undefined {
   return `{ logger: options.loggingOptions?.logger ?? logger.info }`;
 }
 
+/**
+ * Builds the `userAgentOptions` for the generated client, producing a telemetry
+ * prefix of the form `[<application_id> ]azsdk-js-<package>/<version>` per the Azure
+ * Core telemetry policy: https://azure.github.io/azure-sdk/general_azurecore.html#telemetry-policy
+ */
 export function buildUserAgentOptions(
   context: StatementedNode,
   emitterOptions: ModularEmitterOptions,
-  sdkUserAgentPrefix: string,
 ): string {
   const userAgentStatements = [];
   const prefixFromOptions = "const prefixFromOptions = options?.userAgentOptions?.userAgentPrefix;";
@@ -329,21 +333,20 @@ export function buildUserAgentOptions(
   const packageVersion = emitterOptions.options.packageDetails?.version ?? "";
 
   const userAgentInfoStatement =
-    packageVersion && clientPackageName && sdkUserAgentPrefix.includes("api")
+    packageVersion && clientPackageName
       ? "const userAgentInfo = `azsdk-js-" + clientPackageName + "/" + packageVersion + "`;"
       : "";
 
-  if (userAgentInfoStatement) {
-    userAgentStatements.push(userAgentInfoStatement);
+  if (!userAgentInfoStatement) {
+    // Without package name/version we cannot build a meaningful telemetry token,
+    // so we leave the user agent untouched (the caller's userAgentOptions still flow
+    // through `...options`) and let core-rest-pipeline defaults apply.
+    return "";
   }
-  const userAgentPrefix = `const userAgentPrefix = ${
-    "prefixFromOptions ? `${prefixFromOptions} " +
-    sdkUserAgentPrefix +
-    `${userAgentInfoStatement ? " ${userAgentInfo}" : ""}` +
-    "` : `" +
-    `${sdkUserAgentPrefix}` +
-    `${userAgentInfoStatement ? " ${userAgentInfo}`" : "`"}`
-  };`;
+
+  userAgentStatements.push(userAgentInfoStatement);
+  const userAgentPrefix =
+    "const userAgentPrefix = prefixFromOptions ? `${prefixFromOptions} ${userAgentInfo}` : `${userAgentInfo}`;";
   userAgentStatements.push(userAgentPrefix);
 
   context.addStatements(userAgentStatements.join("\n"));

package/src/modular/helpers/example-value-helpers.ts

@@ -12,10 +12,10 @@ import { joinPaths } from "@typespec/compiler";
 import { SourceFile } from "ts-morph";
 import { useContext } from "../../context-manager.js";
 import { resolveReference } from "../../framework/reference.js";
-import { NameType, normalizeName } from "../../rlc-common/index.js";
-import { getSubscriptionId } from "../../transform/transfrom-rlc-options.js";
+import { getSubscriptionId } from "../../transform/transform-client-options.js";
 import { hasKeyCredential, hasTokenCredential } from "../../utils/credential-utils.js";
 import { SdkContext } from "../../utils/interfaces.js";
+import { NameType, normalizeName } from "../../utils/name-utils.js";
 import { getMethodHierarchiesMap, ServiceOperation } from "../../utils/operation-util.js";
 import { AzureIdentityDependencies, AzureTestDependencies } from "../external-dependencies.js";
 import { getClientParametersDeclaration } from "./client-helpers.js";

package/src/modular/helpers/naming-helpers.ts

@@ -1,6 +1,6 @@
 import { SdkClientType, SdkServiceOperation } from "@azure-tools/typespec-client-generator-core";
-import { NameType, normalizeName, ReservedModelNames } from "../../rlc-common/index.js";
 import { SdkContext } from "../../utils/interfaces.js";
+import { NameType, normalizeName, ReservedModelNames } from "../../utils/name-utils.js";
 import { ServiceOperation } from "../../utils/operation-util.js";
 
 export function getClientName(client: SdkClientType<SdkServiceOperation>): string {
@@ -21,7 +21,7 @@ export function getOperationName(
   dpgContext?: SdkContext,
 ): GuardedName {
   const norm = normalizeName(operation.name, NameType.Method, true);
-  const isDataplane = dpgContext !== undefined && !dpgContext.rlcOptions?.azureArm;
+  const isDataplane = dpgContext !== undefined && !dpgContext.emitterOptions?.azureArm;
   if (isReservedName(operation.name, NameType.Method) && isDataplane) {
     return {
       name: norm,