Incorporate code changes for Windows App SDK 1.8-experimental1

thomasclaudiushuber · thomasclaudiushuber · commit 228fe7888d52 · 2025-05-04T11:07:46.000+02:00
diff --git a/docs/apis/get-started.md b/docs/apis/get-started.md
@@ -197,18 +197,18 @@ The following snippet shows how to check for model availability and generate a r
             if (LanguageModel.GetReadyState() == AIFeatureReadyState.EnsureNeeded)
             {
                 var result = await LanguageModel.EnsureReadyAsync();
-                if (result.Status != PackageDeploymentStatus.CompletedSuccess)
+                if (result.Status != AIFeatureReadyResultState.Success)
                 {
-                    throw new Exception(result.ExtendedError().Message);
+                    throw new Exception(result.ExtendedError.Message);
                 }
             }            
 
             using LanguageModel languageModel = 
                await LanguageModel.CreateAsync();
 
             string prompt = "Provide the molecular formula of glucose.";
-            var result = await languageModel.GenerateResponseAsync(prompt);
-            OutputText.Text = result.Response;
+            var response = await languageModel.GenerateResponseAsync(prompt);
+            OutputText.Text = response.Text;
         }
     }
     ```
@@ -249,17 +249,17 @@ The following snippet shows how to check for model availability and generate a r
             if (LanguageModel.GetReadyState() == AIFeatureReadyState.EnsureNeeded)
             {
                 var result = await LanguageModel.EnsureReadyAsync();
-                if (result.Status != PackageDeploymentStatus.CompletedSuccess)
+                if (result.Status != AIFeatureReadyResultState.Success)
                 {
-                    throw new Exception(result.ExtendedError().Message);
+                    throw new Exception(result.ExtendedError.Message);
                 }
             }            
 
             using LanguageModel languageModel = await LanguageModel.CreateAsync();
 
             string prompt = "Provide the molecular formula for glucose.";
-            var result = await languageModel.GenerateResponseAsync(prompt);
-            OutputText.Text = result.Response;
+            var response = await languageModel.GenerateResponseAsync(prompt);
+            OutputText.Text = response.Text;
         }
     }
     ```
@@ -296,17 +296,17 @@ The following snippet shows how to check for model availability and generate a r
             if (LanguageModel.GetReadyState() == AIFeatureReadyState.EnsureNeeded)
             {
                 var result = await LanguageModel.EnsureReadyAsync();
-                if (result.Status != PackageDeploymentStatus.CompletedSuccess)
+                if (result.Status != AIFeatureReadyResultState.Success)
                 {
-                    throw new Exception(result.ExtendedError().Message);
+                    throw new Exception(result.ExtendedError.Message);
                 }
             }            
 
             using LanguageModel languageModel = await LanguageModel.CreateAsync();
 
             string prompt = "Provide the molecular formula for glucose.";
-            var result = await languageModel.GenerateResponseAsync(prompt);
-            OutputLabel.Text = result.Response;
+            var response = await languageModel.GenerateResponseAsync(prompt);
+            OutputLabel.Text = response.Text;
         }
     }
     ```
diff --git a/docs/apis/imaging-tutorial.md b/docs/apis/imaging-tutorial.md
@@ -56,9 +56,9 @@ In the second file listed above, you'll find the following function, which demon
                     if (ImageScaler.GetReadyState() == AIFeatureReadyState.EnsureNeeded)
                     {
                         var op = await ImageScaler.EnsureReadyAsync();
-                        if (op.Status != PackageDeploymentStatus.CompletedSuccess)
+                        if (op.Status != AIFeatureReadyResultState.Success)
                         {
-                            throw new Exception(op.ExtendedError().Message);
+                            throw new Exception(op.ExtendedError.Message);
                         }
                     }
 
diff --git a/docs/apis/imaging.md b/docs/apis/imaging.md
@@ -46,7 +46,7 @@ using Windows.Graphics.Imaging;
 if (ImageScaler.GetReadyState() == AIFeatureReadyState.EnsureNeeded) 
 {
     var result = await ImageScaler.EnsureReadyAsync();
-    if (result.Status != PackageDeploymentStatus.CompletedSuccess)
+    if (result.Status != AIFeatureReadyResultState.Success)
     {
         throw result.ExtendedError;
     }
@@ -69,7 +69,7 @@ using namespace winrt::Windows::Graphics::Imaging;
 if (ImageScaler::GetReadyState() == AIFeatureReadyState::EnsureNeeded) 
 { 
     winrt::PackageDeploymentResult result = ImageScaler::EnsureReadyAsync().get(); 
-    if (result.Status() != PackageDeploymentStatus::CompletedSuccess)
+    if (result.Status() != AIFeatureReadyResultState::Success)
     {
        throw result.ExtendedError();
     }
@@ -128,7 +128,7 @@ using Windows.Graphics.Imaging;
 if (ImageDescriptionGenerator.GetReadyState() == AIFeatureReadyState.EnsureNeeded) 
 {
     var result = await ImageDescriptionGenerator.EnsureReadyAsync();
-    if (result.Status != PackageDeploymentStatus.CompletedSuccess)
+    if (result.Status != AIFeatureReadyResultState.Success)
     {
         throw result.ExtendedError;
     }
@@ -145,8 +145,8 @@ filterOptions.PromptMinSeverityLevelToBlock.ViolentContentSeverity = SeverityLev
 filterOptions.ResponseMinSeverityLevelToBlock.ViolentContentSeverity = SeverityLevel.Medium;
 
 // Get text description.
-LanguageModelResponse languageModelResponse = await imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionScenario.Caption, filterOptions);
-string response = languageModelResponse.Response;
+LanguageModelResponseResult languageModelResponseResult = await imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionScenario.Caption, filterOptions);
+string response = languageModelResponseResult.Text;
 
 ```
 
@@ -171,7 +171,7 @@ using namespace winrt::Windows::Storage::StorageFile;
 if (ImageDescriptionGenerator::GetReadyState() == AIFeatureReadyState::EnsureNeeded) 
 { 
     winrt::PackageDeploymentResult result = ImageDescriptionGenerator::EnsureReadyAsync().get(); 
-    if (result.Status() != PackageDeploymentStatus::CompletedSuccess)
+    if (result.Status() != AIFeatureReadyResultState::Success)
     {
        throw result.ExtendedError();
     }
@@ -188,8 +188,8 @@ auto inputBuffer = ImageBuffer::CreateCopyFromBitmap(softwareBitmap);
 
 
 // Get text description.
-LanguageModelResponse languageModelResponse = imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionScenario::Caption, contentFilter).get();
-string text = languageModelResponse.Response();
+LanguageModelResponseResult languageModelResponseResult = imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionScenario::Caption, contentFilter).get();
+string text = languageModelResponseResult.Text();
 ```
 
 ## What can I do with Image Segmentation?
@@ -233,7 +233,7 @@ using Windows.Graphics.Imaging;
 if (ImageObjectExtractor::GetReadyState() == AIFeatureReadyState.EnsureNeeded) 
 {
     var result = await ImageObjectExtractor.EnsureReadyAsync();
-    if (result.Status != PackageDeploymentStatus.CompletedSuccess)
+    if (result.Status != AIFeatureReadyResultState.Success)
     {
         throw result.ExtendedError;
     }
@@ -263,7 +263,7 @@ using namespace winrt::Windows::Foundation;
 if (ImageObjectExtractor::GetReadyState() == AIFeatureReadyState::EnsureNeeded) 
 { 
     winrt::PackageDeploymentResult result = ImageObjectExtractor::EnsureReadyAsync().get(); 
-    if (result.Status() != PackageDeploymentStatus::CompletedSuccess)
+    if (result.Status() != AIFeatureReadyResultState::Success)
     {
        throw result.ExtendedError();
     }
@@ -355,7 +355,7 @@ using Windows.Graphics.Imaging;
 if (ImageObjectRemover::GetReadyState() == AIFeatureReadyState.EnsureNeeded) 
 {
     var result = await ImageObjectRemover.EnsureReadyAsync();
-    if (result.Status != PackageDeploymentStatus.CompletedSuccess)
+    if (result.Status != AIFeatureReadyResultState.Success)
     {
         throw result.ExtendedError;
     }
@@ -377,7 +377,7 @@ using namespace winrt::Windows::Foundation;
 if (ImageObjectRemover::GetReadyState() == AIFeatureReadyState::EnsureNeeded) 
 { 
     winrt::PackageDeploymentResult result = ImageObjectRemover::EnsureReadyAsync().get(); 
-    if (result.Status() != PackageDeploymentStatus::CompletedSuccess)
+    if (result.Status() != AIFeatureReadyResultState::Success)
     {
        throw result.ExtendedError();
     } 
diff --git a/docs/apis/phi-silica-tutorial.md b/docs/apis/phi-silica-tutorial.md
@@ -32,9 +32,9 @@ In the second file listed above, you'll find the following function, which demon
             {
                 answer.Text = "Making LanguageModel available...";
                 var op = await LanguageModel.EnsureReadyAsync();
-                if (op.Status != PackageDeploymentStatus.CompletedSuccess)
+                if (op.Status != AIFeatureReadyResultState.Success)
                 {
-                    throw new Exception(op.ExtendedError().Message);
+                    throw new Exception(op.ExtendedError.Message);
                 }
             }
 
@@ -44,7 +44,7 @@ In the second file listed above, you'll find the following function, which demon
             string prompt = entryPrompt.Text;
 
             answer.Text = "Generating response...";
-            Windows.Foundation.AsyncOperationProgressHandler<LanguageModelResponse, string>
+            Windows.Foundation.AsyncOperationProgressHandler<LanguageModelResponseResult, string>
             progressHandler = (asyncInfo, delta) =>
             {
                 System.Diagnostics.Debug.WriteLine($"Progress: {delta}");
@@ -58,8 +58,8 @@ In the second file listed above, you'll find the following function, which demon
 
             asyncOp.Progress = progressHandler;
 
-            var result = await asyncOp;
-            System.Diagnostics.Debug.WriteLine("DONE: " + result.Response);
+            var response = await asyncOp;
+            System.Diagnostics.Debug.WriteLine("DONE: " + response.Text);
         }
 ```
 ![The sample app after calling the ImageScaler and LanguageModel APIs.](../images/API-Tutorial-MAUIappimage2(aftercallingSuperResandLanguageModelAPIs).png)
diff --git a/docs/apis/phi-silica.md b/docs/apis/phi-silica.md
@@ -135,22 +135,22 @@ This example shows how to generate a response to a Q&A prompt where the response
 
 1. Create a **LanguageModel** object to reference the local language model. *A check has already been performed to ensure the Phi Silica language model is available on the user's device in the previous snippet.
 
-1. Asynchronously retrieve the **LanguageModelResponse** in a call to **GenerateResponseWithProgressAsync**. Write it to the console as the response is generated.
+1. Asynchronously retrieve the **LanguageModelResponseResult** in a call to **GenerateResponseAsync**. Write it to the console as the response is generated.
 
 ### [C#](#tab/csharp2)
 ```csharp
 using LanguageModel languageModel = await LanguageModel.CreateAsync(); 
  
 string prompt = "Introduce yourself."; 
  
-AsyncOperationProgressHandler<LanguageModelResponse, string> 
+AsyncOperationProgressHandler<LanguageModelResponseResult, string> 
 progressHandler = (asyncInfo, delta) => 
 { 
     Console.WriteLine($"Progress: {delta}"); 
-    Console.WriteLine($"Response so far: {asyncInfo.GetResults().Response}"); 
+    Console.WriteLine($"Response so far: {asyncInfo.GetResults().Text}"); 
  }; 
  
-var asyncOp = languageModel.GenerateResponseWithProgressAsync(prompt); 
+var asyncOp = languageModel.GenerateResponseAsync(prompt); 
  
 asyncOp.Progress = progressHandler; 
  
@@ -165,14 +165,14 @@ auto languageModel = LanguageModel::CreateAsync().get();
 
 std::string prompt = "Introduce yourself.";
 
-AsyncOperationProgressHandler<LanguageModelResponse, std::string> progressHandler = 
-    [](const IAsyncOperationWithProgress<LanguageModelResponse, std::string>& asyncInfo, const std::string& delta) 
+AsyncOperationProgressHandler<LanguageModelResponseResult, std::string> progressHandler = 
+    [](const IAsyncOperationWithProgress<LanguageModelResponseResult, std::string>& asyncInfo, const std::string& delta) 
     { 
         std::cout << "Progress: " << delta << std::endl; 
-        std::cout << "Response so far: " << asyncInfo.GetResults().Response << std::endl; 
+        std::cout << "Response so far: " << asyncInfo.GetResults().Text << std::endl; 
     };
 
-auto asyncOp = languageModel.GenerateResponseWithProgressAsync(prompt);
+auto asyncOp = languageModel.GenerateResponseAsync(prompt);
 
 asyncOp.Progress(progressHandler); 
 
@@ -201,7 +201,7 @@ Phi Silica includes the ability to predefine text response formats for use in yo
     | **LanguageModelSkill.Summarize**    | Return a summary based on the prompt text.  |
     | **LanguageModelSkill.Rewrite**  | Rewrite the prompt text response to improve clarity and comprehension.  |
 
-3. Then we asynchronously retrieve the **LanguageModelResponse** in a call to **GenerateResponseWithProgressAsync** and write it to the console as the response is generated.
+3. Then we asynchronously retrieve the **LanguageModelResponseResult** in a call to **GenerateResponseAsync** and write it to the console as the response is generated.
 
 ### [C#](#tab/csharp3)
 ```csharp
diff --git a/docs/apis/text-recognition.md b/docs/apis/text-recognition.md
@@ -121,9 +121,9 @@ public async Task<TextRecognizer> EnsureModelIsReady()
     if (TextRecognizer.GetReadyState() == AIFeatureReadyState.EnsureNeeded)
     {
         var loadResult = await TextRecognizer.EnsureReadyAsync();
-        if (loadResult.Status != PackageDeploymentStatus.CompletedSuccess)
+        if (loadResult.Status != AIFeatureReadyResultState.Success)
         {
-            throw new Exception(loadResult.ExtendedError().Message);
+            throw new Exception(loadResult.ExtendedError.Message);
         }
     }
 
@@ -160,7 +160,7 @@ winrt::IAsyncOperation<winrt::TextRecognizer> EnsureModelIsReady()
   if (winrt::TextRecognizer::GetReadyState() == AIFeatureReadyState::EnsureNeeded) 
   {
     auto loadResult = co_await winrt::TextRecognizer::EnsureReadyAsync();
-    if (loadResult.Status() != winrt::PackageDeploymentStatus::CompletedSuccess)
+    if (loadResult.Status() != winrt::AIFeatureReadyResultState::Success)
     {
         throw winrt::hresult_error(loadResult.ExtendedError());
     }

Original file line number	Diff line number	Diff line change
`@@ -197,18 +197,18 @@ The following snippet shows how to check for model availability and generate a r`
`197`	`197`	`if (LanguageModel.GetReadyState() == AIFeatureReadyState.EnsureNeeded)`
`198`	`198`	`{`
`199`	`199`	`var result = await LanguageModel.EnsureReadyAsync();`
`200`		`- if (result.Status != PackageDeploymentStatus.CompletedSuccess)`
	`200`	`+ if (result.Status != AIFeatureReadyResultState.Success)`
`201`	`201`	`{`
`202`		`- throw new Exception(result.ExtendedError().Message);`
	`202`	`+ throw new Exception(result.ExtendedError.Message);`
`203`	`203`	`}`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`using LanguageModel languageModel =`
`207`	`207`	`await LanguageModel.CreateAsync();`
`208`	`208`
`209`	`209`	`string prompt = "Provide the molecular formula of glucose.";`
`210`		`- var result = await languageModel.GenerateResponseAsync(prompt);`
`211`		`- OutputText.Text = result.Response;`
	`210`	`+ var response = await languageModel.GenerateResponseAsync(prompt);`
	`211`	`+ OutputText.Text = response.Text;`
`212`	`212`	`}`
`213`	`213`	`}`
`214`	`214`	```
`@@ -249,17 +249,17 @@ The following snippet shows how to check for model availability and generate a r`
`249`	`249`	`if (LanguageModel.GetReadyState() == AIFeatureReadyState.EnsureNeeded)`
`250`	`250`	`{`
`251`	`251`	`var result = await LanguageModel.EnsureReadyAsync();`
`252`		`- if (result.Status != PackageDeploymentStatus.CompletedSuccess)`
	`252`	`+ if (result.Status != AIFeatureReadyResultState.Success)`
`253`	`253`	`{`
`254`		`- throw new Exception(result.ExtendedError().Message);`
	`254`	`+ throw new Exception(result.ExtendedError.Message);`
`255`	`255`	`}`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	`using LanguageModel languageModel = await LanguageModel.CreateAsync();`
`259`	`259`
`260`	`260`	`string prompt = "Provide the molecular formula for glucose.";`
`261`		`- var result = await languageModel.GenerateResponseAsync(prompt);`
`262`		`- OutputText.Text = result.Response;`
	`261`	`+ var response = await languageModel.GenerateResponseAsync(prompt);`
	`262`	`+ OutputText.Text = response.Text;`
`263`	`263`	`}`
`264`	`264`	`}`
`265`	`265`	```
`@@ -296,17 +296,17 @@ The following snippet shows how to check for model availability and generate a r`
`296`	`296`	`if (LanguageModel.GetReadyState() == AIFeatureReadyState.EnsureNeeded)`
`297`	`297`	`{`
`298`	`298`	`var result = await LanguageModel.EnsureReadyAsync();`
`299`		`- if (result.Status != PackageDeploymentStatus.CompletedSuccess)`
	`299`	`+ if (result.Status != AIFeatureReadyResultState.Success)`
`300`	`300`	`{`
`301`		`- throw new Exception(result.ExtendedError().Message);`
	`301`	`+ throw new Exception(result.ExtendedError.Message);`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`
`305`	`305`	`using LanguageModel languageModel = await LanguageModel.CreateAsync();`
`306`	`306`
`307`	`307`	`string prompt = "Provide the molecular formula for glucose.";`
`308`		`- var result = await languageModel.GenerateResponseAsync(prompt);`
`309`		`- OutputLabel.Text = result.Response;`
	`308`	`+ var response = await languageModel.GenerateResponseAsync(prompt);`
	`309`	`+ OutputLabel.Text = response.Text;`
`310`	`310`	`}`
`311`	`311`	`}`
`312`	`312`	```
Original file line number	Diff line number	Diff line change
`@@ -56,9 +56,9 @@ In the second file listed above, you'll find the following function, which demon`
`56`	`56`	`if (ImageScaler.GetReadyState() == AIFeatureReadyState.EnsureNeeded)`
`57`	`57`	`{`
`58`	`58`	`var op = await ImageScaler.EnsureReadyAsync();`
`59`		`- if (op.Status != PackageDeploymentStatus.CompletedSuccess)`
	`59`	`+ if (op.Status != AIFeatureReadyResultState.Success)`
`60`	`60`	`{`
`61`		`- throw new Exception(op.ExtendedError().Message);`
	`61`	`+ throw new Exception(op.ExtendedError.Message);`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ using Windows.Graphics.Imaging;`
`46`	`46`	`if (ImageScaler.GetReadyState() == AIFeatureReadyState.EnsureNeeded)`
`47`	`47`	`{`
`48`	`48`	`var result = await ImageScaler.EnsureReadyAsync();`
`49`		`- if (result.Status != PackageDeploymentStatus.CompletedSuccess)`
	`49`	`+ if (result.Status != AIFeatureReadyResultState.Success)`
`50`	`50`	`{`
`51`	`51`	`throw result.ExtendedError;`
`52`	`52`	`}`
`@@ -69,7 +69,7 @@ using namespace winrt::Windows::Graphics::Imaging;`
`69`	`69`	`if (ImageScaler::GetReadyState() == AIFeatureReadyState::EnsureNeeded)`
`70`	`70`	`{`
`71`	`71`	`winrt::PackageDeploymentResult result = ImageScaler::EnsureReadyAsync().get();`
`72`		`- if (result.Status() != PackageDeploymentStatus::CompletedSuccess)`
	`72`	`+ if (result.Status() != AIFeatureReadyResultState::Success)`
`73`	`73`	`{`
`74`	`74`	`throw result.ExtendedError();`
`75`	`75`	`}`
`@@ -128,7 +128,7 @@ using Windows.Graphics.Imaging;`
`128`	`128`	`if (ImageDescriptionGenerator.GetReadyState() == AIFeatureReadyState.EnsureNeeded)`
`129`	`129`	`{`
`130`	`130`	`var result = await ImageDescriptionGenerator.EnsureReadyAsync();`
`131`		`- if (result.Status != PackageDeploymentStatus.CompletedSuccess)`
	`131`	`+ if (result.Status != AIFeatureReadyResultState.Success)`
`132`	`132`	`{`
`133`	`133`	`throw result.ExtendedError;`
`134`	`134`	`}`
`@@ -145,8 +145,8 @@ filterOptions.PromptMinSeverityLevelToBlock.ViolentContentSeverity = SeverityLev`
`145`	`145`	`filterOptions.ResponseMinSeverityLevelToBlock.ViolentContentSeverity = SeverityLevel.Medium;`
`146`	`146`
`147`	`147`	`// Get text description.`
`148`		`-LanguageModelResponse languageModelResponse = await imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionScenario.Caption, filterOptions);`
`149`		`-string response = languageModelResponse.Response;`
	`148`	`+LanguageModelResponseResult languageModelResponseResult = await imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionScenario.Caption, filterOptions);`
	`149`	`+string response = languageModelResponseResult.Text;`
`150`	`150`
`151`	`151`	```
`152`	`152`
`@@ -171,7 +171,7 @@ using namespace winrt::Windows::Storage::StorageFile;`
`171`	`171`	`if (ImageDescriptionGenerator::GetReadyState() == AIFeatureReadyState::EnsureNeeded)`
`172`	`172`	`{`
`173`	`173`	`winrt::PackageDeploymentResult result = ImageDescriptionGenerator::EnsureReadyAsync().get();`
`174`		`- if (result.Status() != PackageDeploymentStatus::CompletedSuccess)`
	`174`	`+ if (result.Status() != AIFeatureReadyResultState::Success)`
`175`	`175`	`{`
`176`	`176`	`throw result.ExtendedError();`
`177`	`177`	`}`
`@@ -188,8 +188,8 @@ auto inputBuffer = ImageBuffer::CreateCopyFromBitmap(softwareBitmap);`
`188`	`188`
`189`	`189`
`190`	`190`	`// Get text description.`
`191`		`-LanguageModelResponse languageModelResponse = imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionScenario::Caption, contentFilter).get();`
`192`		`-string text = languageModelResponse.Response();`
	`191`	`+LanguageModelResponseResult languageModelResponseResult = imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionScenario::Caption, contentFilter).get();`
	`192`	`+string text = languageModelResponseResult.Text();`
`193`	`193`	```
`194`	`194`
`195`	`195`	`## What can I do with Image Segmentation?`
`@@ -233,7 +233,7 @@ using Windows.Graphics.Imaging;`
`233`	`233`	`if (ImageObjectExtractor::GetReadyState() == AIFeatureReadyState.EnsureNeeded)`
`234`	`234`	`{`
`235`	`235`	`var result = await ImageObjectExtractor.EnsureReadyAsync();`
`236`		`- if (result.Status != PackageDeploymentStatus.CompletedSuccess)`
	`236`	`+ if (result.Status != AIFeatureReadyResultState.Success)`
`237`	`237`	`{`
`238`	`238`	`throw result.ExtendedError;`
`239`	`239`	`}`
`@@ -263,7 +263,7 @@ using namespace winrt::Windows::Foundation;`
`263`	`263`	`if (ImageObjectExtractor::GetReadyState() == AIFeatureReadyState::EnsureNeeded)`
`264`	`264`	`{`
`265`	`265`	`winrt::PackageDeploymentResult result = ImageObjectExtractor::EnsureReadyAsync().get();`
`266`		`- if (result.Status() != PackageDeploymentStatus::CompletedSuccess)`
	`266`	`+ if (result.Status() != AIFeatureReadyResultState::Success)`
`267`	`267`	`{`
`268`	`268`	`throw result.ExtendedError();`
`269`	`269`	`}`
`@@ -355,7 +355,7 @@ using Windows.Graphics.Imaging;`
`355`	`355`	`if (ImageObjectRemover::GetReadyState() == AIFeatureReadyState.EnsureNeeded)`
`356`	`356`	`{`
`357`	`357`	`var result = await ImageObjectRemover.EnsureReadyAsync();`
`358`		`- if (result.Status != PackageDeploymentStatus.CompletedSuccess)`
	`358`	`+ if (result.Status != AIFeatureReadyResultState.Success)`
`359`	`359`	`{`
`360`	`360`	`throw result.ExtendedError;`
`361`	`361`	`}`
`@@ -377,7 +377,7 @@ using namespace winrt::Windows::Foundation;`
`377`	`377`	`if (ImageObjectRemover::GetReadyState() == AIFeatureReadyState::EnsureNeeded)`
`378`	`378`	`{`
`379`	`379`	`winrt::PackageDeploymentResult result = ImageObjectRemover::EnsureReadyAsync().get();`
`380`		`- if (result.Status() != PackageDeploymentStatus::CompletedSuccess)`
	`380`	`+ if (result.Status() != AIFeatureReadyResultState::Success)`
`381`	`381`	`{`
`382`	`382`	`throw result.ExtendedError();`
`383`	`383`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,9 +32,9 @@ In the second file listed above, you'll find the following function, which demon`
`32`	`32`	`{`
`33`	`33`	`answer.Text = "Making LanguageModel available...";`
`34`	`34`	`var op = await LanguageModel.EnsureReadyAsync();`
`35`		`- if (op.Status != PackageDeploymentStatus.CompletedSuccess)`
	`35`	`+ if (op.Status != AIFeatureReadyResultState.Success)`
`36`	`36`	`{`
`37`		`- throw new Exception(op.ExtendedError().Message);`
	`37`	`+ throw new Exception(op.ExtendedError.Message);`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`
`@@ -44,7 +44,7 @@ In the second file listed above, you'll find the following function, which demon`
`44`	`44`	`string prompt = entryPrompt.Text;`
`45`	`45`
`46`	`46`	`answer.Text = "Generating response...";`
`47`		`- Windows.Foundation.AsyncOperationProgressHandler<LanguageModelResponse, string>`
	`47`	`+ Windows.Foundation.AsyncOperationProgressHandler<LanguageModelResponseResult, string>`
`48`	`48`	`progressHandler = (asyncInfo, delta) =>`
`49`	`49`	`{`
`50`	`50`	`System.Diagnostics.Debug.WriteLine($"Progress: {delta}");`
`@@ -58,8 +58,8 @@ In the second file listed above, you'll find the following function, which demon`
`58`	`58`
`59`	`59`	`asyncOp.Progress = progressHandler;`
`60`	`60`
`61`		`- var result = await asyncOp;`
`62`		`- System.Diagnostics.Debug.WriteLine("DONE: " + result.Response);`
	`61`	`+ var response = await asyncOp;`
	`62`	`+ System.Diagnostics.Debug.WriteLine("DONE: " + response.Text);`
`63`	`63`	`}`
`64`	`64`	```
`65`	`65`	`![The sample app after calling the ImageScaler and LanguageModel APIs.](../images/API-Tutorial-MAUIappimage2(aftercallingSuperResandLanguageModelAPIs).png)`
Original file line number	Diff line number	Diff line change
`@@ -121,9 +121,9 @@ public async Task<TextRecognizer> EnsureModelIsReady()`
`121`	`121`	`if (TextRecognizer.GetReadyState() == AIFeatureReadyState.EnsureNeeded)`
`122`	`122`	`{`
`123`	`123`	`var loadResult = await TextRecognizer.EnsureReadyAsync();`
`124`		`- if (loadResult.Status != PackageDeploymentStatus.CompletedSuccess)`
	`124`	`+ if (loadResult.Status != AIFeatureReadyResultState.Success)`
`125`	`125`	`{`
`126`		`- throw new Exception(loadResult.ExtendedError().Message);`
	`126`	`+ throw new Exception(loadResult.ExtendedError.Message);`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`
`@@ -160,7 +160,7 @@ winrt::IAsyncOperation<winrt::TextRecognizer> EnsureModelIsReady()`
`160`	`160`	`if (winrt::TextRecognizer::GetReadyState() == AIFeatureReadyState::EnsureNeeded)`
`161`	`161`	`{`
`162`	`162`	`auto loadResult = co_await winrt::TextRecognizer::EnsureReadyAsync();`
`163`		`- if (loadResult.Status() != winrt::PackageDeploymentStatus::CompletedSuccess)`
	`163`	`+ if (loadResult.Status() != winrt::AIFeatureReadyResultState::Success)`
`164`	`164`	`{`
`165`	`165`	`throw winrt::hresult_error(loadResult.ExtendedError());`
`166`	`166`	`}`