Merge branch 'main' into release-ga-lbcd

Author: v-alje

articles/api-management/azure-ai-foundry-api.md

@@ -27,16 +27,16 @@ API Management supports two client compatibility options for AI APIs. Choose the
 
 * **Azure AI** - Manage model endpoints in Azure AI Foundry that are exposed through the [Azure AI Model Inference API](/azure/ai-studio/reference/reference-model-inference-api).
 
-    Clients call the deployment at a `/models` endpoint such as `/my-model/models/chat/completions`. Deployment name is passed in the request body. Use this option if you want flexibility to switch between models exposed through the Azure AI Model Inference API and those deployed in Azure OpenAI Service.
+    Clients call the deployment at a `/models` endpoint such as `/my-model/models/chat/completions`. Deployment name is passed in the request body. Use this option if you want flexibility to switch between models exposed through the Azure AI Model Inference API and those deployed in Azure OpenAI in Foundry Models.
 
-* **Azure OpenAI Service** - Manage model endpoints deployed in Azure OpenAI Service. 
+* **Azure OpenAI** - Manage model endpoints deployed in Azure OpenAI. 
 
-    Clients call the deployment at an `/openai` endpoint such as `/openai/deployments/my-deployment/chat/completions`. Deployment name is passed in the request path. Use this option if your AI service only includes Azure OpenAI Service model deployments. 
+    Clients call the deployment at an `/openai` endpoint such as `/openai/deployments/my-deployment/chat/completions`. Deployment name is passed in the request path. Use this option if your AI service only includes Azure OpenAI model deployments. 
 
 ## Prerequisites
 
 - An existing API Management instance. [Create one if you haven't already](get-started-create-service-instance.md).
-- An Azure AI service in your subscription with one or more models deployed. Examples include models deployed in Azure AI Foundry or Azure OpenAI Service.
+- An Azure AI service in your subscription with one or more models deployed. Examples include Azure OpenAI or other models deployed in Azure AI Foundry.
 
 ## Import AI Foundry API using the portal
 
@@ -67,7 +67,7 @@ To import an AI Foundry API to API Management:
     1. In **Base path**, enter a path that your API Management instance uses to access the deployment endpoint.
     1. Optionally select one or more **Products** to associate with the API.  
     1. In **Client compatibility**, select either of the following based on the types of client you intend to support. See [Client compatibility options](#client-compatibility-options) for more information.
-        * **Azure OpenAI** - Select this option if your clients only need to access Azure OpenAI Service model deployments.
+        * **Azure OpenAI** - Select this option if your clients only need to access Azure OpenAI model deployments.
         * **Azure AI** - Select this option if your clients need to access other models in Azure AI Foundry. 
     1. Select **Next**.
 

articles/api-management/azure-openai-enable-semantic-caching.md

@@ -22,8 +22,8 @@ Enable semantic caching of responses to Azure OpenAI API requests to reduce band
 
 ## Prerequisites
 
-* One or more Azure OpenAI Service APIs must be added to your API Management instance. For more information, see [Add an Azure OpenAI Service API to Azure API Management](azure-openai-api-from-specification.md).
-* The Azure OpenAI service must have deployments for the following:
+* One or more Azure OpenAI in Foundry Models APIs must be added to your API Management instance. For more information, see [Add an Azure OpenAI API to Azure API Management](azure-openai-api-from-specification.md).
+* The Azure OpenAI instance must have deployments for the following:
     * Chat Completion API - Deployment used for API consumer calls 
     * Embeddings API - Deployment used for semantic caching
 * The API Management instance must be configured to use managed identity authentication to the Azure OpenAI APIs. For more information, see [Authenticate and authorize access to Azure OpenAI APIs using Azure API Management ](api-management-authenticate-authorize-azure-openai.md#authenticate-with-managed-identity).
@@ -57,17 +57,17 @@ Configure a [backend](backends.md) resource for the embeddings API deployment wi
 
 * **Name** - A name of your choice, such as `embeddings-backend`. You use this name to reference the backend in policies.
 * **Type** - Select **Custom URL**.
-* **Runtime URL** - The URL of the embeddings API deployment in the Azure OpenAI Service, similar to:
+* **Runtime URL** - The URL of the embeddings API deployment in the Azure OpenAI instance, similar to:
         ```
         https://my-aoai.openai.azure.com/openai/deployments/embeddings-deployment/embeddings
         ```
 * **Authorization credentials** - Go to **Managed Identity** tab.
   * **Client identity** - Select *System assigned identity* or type in a User assigned managed identity client ID.
-  * **Resource ID** - Enter `https://cognitiveservices.azure.com/` for Azure OpenAI Service.
+  * **Resource ID** - Enter `https://cognitiveservices.azure.com/` for Azure OpenAI.
 
 ### Test backend 
 
-To test the backend, create an API operation for your Azure OpenAI Service API:
+To test the backend, create an API operation for your Azure OpenAI API:
 
 1. On the **Design** tab of your API, select **+ Add operation**.
 1. Enter a **Display name** and optionally a **Name** for the operation.

articles/azure-functions/durable/durable-functions-http-features.md

@@ -350,13 +350,67 @@ By using the "call HTTP" action, you can do the following actions in your orches
 
 The ability to consume HTTP APIs directly from orchestrator functions is intended as a convenience for a certain set of common scenarios. You can implement all of these features yourself using activity functions. In many cases, activity functions might give you more flexibility.
 
-### <a name="http-202-handling"></a>HTTP 202 handling (.NET in-process only)
+### <a name="http-202-handling"></a>HTTP 202 handling (.NET only)
 
 The "call HTTP" API can automatically implement the client side of the polling consumer pattern. If a called API returns an HTTP 202 response with a Location header, the orchestrator function automatically polls the Location resource until receiving a response other than 202. This response will be the response returned to the orchestrator function code.
 
+# [C# (InProc)](#tab/csharp-inproc)
+
+```csharp
+[FunctionName(nameof(CheckSiteAvailabilityWithPolling))]
+public static async Task CheckSiteAvailabilityWithPolling(
+    [OrchestrationTrigger] IDurableOrchestrationContext context)
+{
+    Uri url = context.GetInput<Uri>();
+
+    // HTTP automatic polling on 202 response is enabled by default in .NET in-process.
+    DurableHttpResponse response = 
+        await context.CallHttpAsync(HttpMethod.Get, url);
+}
+```
+
+# [C# (Isolated)](#tab/csharp-isolated)
+
+```csharp
+[Function(nameof(CheckSiteAvailabilityWithPolling))]
+public static async Task CheckSiteAvailabilityWithPolling(
+    [OrchestrationTrigger] TaskOrchestrationContext context)
+{
+    Uri url = context.GetInput<Uri>();
+
+    // Enable HTTP automatic polling on 202 response by setting asynchronousPatternEnabled to true.
+    DurableHttpResponse response =await context.CallHttpAsync(
+        HttpMethod.Get,
+        url!,
+        content: null,
+        retryOptions: null,
+        asynchronousPatternEnabled: true)
+}
+
+```
+# [JavaScript](#tab/javascript)
+
+This feature is currently not supported in JavaScript.
+
+# [Python](#tab/python)
+
+This feature is currently not supported in Python.
+
+# [PowerShell](#tab/powershell)
+
+This feature is currently not supported in PowerShell.
+
+# [Java](#tab/java)
+
+This feature is currently not supported in Java.
+
+---
+
 > [!NOTE]
 > 1. Orchestrator functions also natively support the server-side polling consumer pattern, as described in [Async operation tracking](#async-operation-tracking). This support means that orchestrations in one function app can easily coordinate the orchestrator functions in other function apps. This is similar to the [sub-orchestration](durable-functions-sub-orchestrations.md) concept, but with support for cross-app communication. This support is particularly useful for microservice-style app development.
-> 2. The built-in HTTP polling pattern is currently available only in the .NET in-process host.
+> 2. The built-in HTTP polling pattern is currently available only in the .NET host.
+> 3. The polling pattern is enabled by default in .NET in-process but disabled by default in .NET Isolated. If you want to enable it in .NET Isolated, refer to the sample code and set the asynchronousPatternEnabled argument to true.
+> 4. HTTP automatic polling pattern is supported in Durable Functions .NET Isolated starting from version [v1.5.0](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.DurableTask) or later.
 
 ### Managed identities
 

articles/azure-functions/functions-how-to-azure-devops.md

@@ -445,7 +445,7 @@ You'll deploy with the [Azure Function App Deploy v2](/azure/devops/pipelines/ta
 
 The v2 version of the task includes support for newer applications stacks for .NET, Python, and Node. The task includes networking predeployment checks. When there are predeployment issues, deployment stops. 
 
-To deploy to Azure Functions, add the following snippet at the end of your `azure-pipelines.yml` file. The default `appType` is Windows. You can specify Linux by setting the `appType` to `functionAppLinux`. Deploying to a Flex Consumption app requires you to set both `appType: functionAppLinux` and `isFlexConsumption: true`.
+To deploy to Azure Functions, add the following snippet at the end of your `azure-pipelines.yml` file. The default `appType` is Windows. You can specify Linux by setting the `appType` to `functionAppLinux`. Deploying to a Flex Consumption app requires you to set both `appType: functionAppLinux` and `isFlexConsumption: true`. The reason must be set to `functionAppLinux` when you use Flex Consumption because [Flex Consumption](/azure/azure-functions/flex-consumption-plan) is a Linux-based Azure Function.
 
 ### [Windows App](#tab/windows)
 ```yaml

articles/azure-resource-manager/bicep/bicep-core-diagnostics.md

@@ -399,7 +399,7 @@ If you need more information about a particular diagnostic code, select the **Fe
 | <a id='BCP417' />BCP417 | Error | The spread operator `{ellipsis}` cannot be used inside objects with property for-expressions.    |
 | <a id='BCP418' />BCP418 | Error | Extensions cannot be referenced here. Extensions can only be referenced by module extension configurations.   |
 | <a id='BCP419' />BCP419 | Error | Namespace name `{name}` cannot be used as an extension name.|
-| <a id='BCP420' />BCP420 | Error | The scope could not be resolved at compile time because the supplied expression is ambiguous or too complex. Scoping expressions must be reducible to a specific kind of scope without knowledge of parameter values. |
+| <a id='BCP420' />[BCP420](./diagnostics/bcp420.md) | Error | The scope could not be resolved at compile time because the supplied expression is ambiguous or too complex. Scoping expressions must be reducible to a specific kind of scope without knowledge of parameter values. |
 | <a id='BCP421' />BCP421 | Error | Module `{moduleName}` contains one or more secure outputs, which are not supported with `{LanguageConstants.TargetScopeKeyword}` set to `{LanguageConstants.TargetScopeTypeLocal}`.|
 | <a id='BCP422' />BCP422 | Error | A resource of type `{baseType}` may or may not exist when this function is called, which could cause the deployment to fail.|
 

articles/azure-resource-manager/bicep/diagnostics/bcp420.md

@@ -0,0 +1,42 @@
+---
+title: BCP420
+description: The scope couldn't be resolved at compile time because the supplied expression is ambiguous or too complex. Scoping expressions must be reducible to a specific kind of scope without knowledge of parameter values.
+ms.topic: reference
+ms.custom: devx-track-bicep
+ms.date: 06/25/2025
+---
+
+# Bicep diagnostic code - BCP420
+
+In Bicep, every resource or module must have a known deployment scope at compile time. The scope must be statically determinable. If the scope depends on a parameter, a variable, or an expression that can't be evaluated during compilation, Bicep throws BCP420.
+
+## Description
+
+The scope couldn't be resolved at compile time because the supplied expression is ambiguous or too complex. Scoping expressions must be reducible to a specific kind of scope without knowledge of parameter values.
+
+## Level
+
+Error
+
+## Examples
+
+The following code triggers BCP420 because the scope can't be determined at the compile time.
+
+```bicep
+param targetResourceGroupName string = 'my-target-rg'
+param storageAccountName string = 'mystorageacct'
+param location string = 'eastus'
+
+module storageModule './module.bicep' = {
+  name: 'deployStorage'
+  scope: empty(targetResourceGroupName) ? resourceGroup() : resourceGroup(targetResourceGroupName)
+  params: {
+    storageAccountName: storageAccountName
+    location: location
+  }
+}
+```
+
+## Next steps
+
+For more information about Bicep diagnostics, see [Bicep core diagnostics](../bicep-core-diagnostics.md).

articles/azure-resource-manager/bicep/toc.yml

@@ -740,5 +740,7 @@ items:
       href: diagnostics/bcp401.md
     - name: BCP414
       href: diagnostics/bcp414.md
+    - name: BCP420
+      href: diagnostics/bcp420.md
   - name: Azure CLI
     href: /cli/azure/resource

articles/communication-services/tutorials/includes/log-file-retrieval-android.md

@@ -2,9 +2,9 @@
 // Call when a support request is being called
 private void onSupportRequest(String userMessage) {
     // Assuming the getSupportFiles method returns a List or similar collection.
-    List<SupportFile> supportFiles = callClient.getdebugInfo().getSupportFiles();
+    List<File> supportFiles = callClient.getdebugInfo().getSupportFiles();
 
     // Send the files and any user message to your Ticket System            
     dispatchSupportRequestToBackend(userMessage, supportFiles);
 }
-```
+```

articles/communication-services/tutorials/includes/log-file-retrieval-windows.md

@@ -3,9 +3,9 @@
 private void OnSupportRequest(string userMessage) 
 {
     // Assuming the GetSupportFiles method returns a List or similar collection.
-    IReadOnlyList<SupportFile> supportFiles = callClient.DebugDetails.SupportFiles;
+    IReadOnlyList<string> supportFiles = callClient.DebugDetails.SupportFiles;
 
     // Send the files and any user message to your Ticket System            
     DispatchSupportRequestToBackend(userMessage, supportFiles);
 }
-```
+```

articles/confidential-computing/guest-attestation-confidential-virtual-machines-design.md

@@ -95,7 +95,6 @@ Refer to [Azure Confidential VMs attestation guidance & FAQ](https://github.com/
 | Report Payload | 32   | 1184 | The hardware report. |
 | Runtime Data   | 1216 | variable length | The runtime data includes claims endorsed by the hardware report. |
 
-
 #### Header
 
 | Name | Offset (bytes) | Size (bytes) | Description |
@@ -115,11 +114,12 @@ The report generated by the hardware (AMD SEV-SNP or Intel TDX). The report_data
 
 | Name | Offset (bytes) | Size (bytes) | Description | Measured |
 | :--- | :--- | :--- | :--- | :--- |
-| Data Size      | 0  | 4 | The size of Runtime Claims. | No |
+| Data Size      | 0  | 4 | The size of Runtime Data. | No |
 | Version        | 4  | 4 | Format version. Expected: 1. | No |
 | Report Type    | 8  | 4 | The type of hardware report. Expected: 2 (AMD SEV-SNP), 4 (Intel TDX) | No |
 | Hash Type      | 12 | 4 | The algorithm used to hash the runtime data. The hash value is captured in the report_data field of the hardware report. Expected: 1 (SHA-256), 2 (SHA-384), 3 (SHA-512) | No |
-| Runtime Claims | 16 | variable length | The runtime claims in JSON format. | Yes |
+| Claim Size     | 16 | 4 | The size of Runtime Claims. | No |
+| Runtime Claims | 20 | variable length | The runtime claims in JSON format. | Yes |
 
 #### Runtime Claims