Fix: Restore full error.details handling for binary wrap-non-model-return deserializers (#3852)

* fix: restore full error.details handling for binary wrap-non-model-return deserializers

The wrap-non-model-return feature (commit 49500ef) introduced early returns
in the binary wrap path that skipped status checking and error.details
extraction in generated deserialize functions.

This fix:
- Adds a new getBinaryStream static helper that separates stream extraction
  from error handling (Node + browser variants)
- Removes the status check skip for binary wrap - all operations now generate
  the full getExceptionThrowStatement with error.details, exception headers,
  and restErrorCodeHeader support
- The deserializer parameter is renamed to _streamableResult for binary wrap,
  with getBinaryStream resolving it into an HttpResponse named result so
  existing error handling code references work unchanged

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* test: add error enrichment scenarios for binary wrap-non-model-return

Adds two new unit test scenarios verifying that binary wrap deserializers
generate full error.details handling:
- Binary wrap + error model: verifies error.details = apiErrorDeserializer(result.body)
- Binary wrap + error model + exception headers: verifies error.details with
  exception header merging via _getBlobDeserializeExceptionHeaders(result)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* test: add storage-compat scenario for void+headers with error enrichment

Verifies that when enable-storage-compat and include-headers-in-response are
both enabled on a void-body operation with response headers and an error model:
1. Deserializer generates error.details = storageErrorDeserializer(result.body)
2. Exception headers are merged into error.details
3. Operation function extracts parsedHeaders and passes them to
   addStorageCompatResponse

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Update smoke tests

* Update for Storage Compat binary response

- move the `getBinaryStream()` call out of `_operationDeserialize()` and into the
operation method `operation()`, where its result is passed to both `_opDeserialize()` and
`_operationDeserializeHeaders()`

- `_operationDeserialize()` now takes the result of `getBinaryStream()`, process and
throw for error response if any; return the wrapped stream body.

- return type is fixed for wrapped operation.

* update smoke test

* attempt to fix missing import of OperationResponse

* react to recent fast-xml-parser change

* Remove unnecessary logic and rename the helper

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Jialin Huang <jialinhuang@microsoft.com>
Co-authored-by: Jeremy Meng <jeremy.ymeng@gmail.com>

Author: 4 people

packages/typespec-test/test/batch_modular/generated/typespec-ts/src/api/operations.ts

@@ -113,7 +113,7 @@ import {
   PagedAsyncIterableIterator,
   buildPagedAsyncIterator,
 } from "../static-helpers/pagingHelpers.js";
-import { getBinaryResponseBody } from "../static-helpers/serialization/get-binary-response-body.js";
+import { getBinaryStreamResponse } from "../static-helpers/serialization/get-binary-stream-response.js";
 import { expandUrlTemplate } from "../static-helpers/urlTemplate.js";
 import {
   ListNodeFilesOptionalParams,
@@ -410,9 +410,17 @@ export function _getNodeFileSend(
 }
 
 export async function _getNodeFileDeserialize(
-  result: StreamableMethod,
+  result: PathUncheckedResponse & GetNodeFileResponse,
 ): Promise<GetNodeFileResponse> {
-  return getBinaryResponseBody(result, ["200"], batchErrorDeserializer);
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = batchErrorDeserializer(result.body);
+
+    throw error;
+  }
+
+  return { blobBody: result.blobBody, readableStreamBody: result.readableStreamBody };
 }
 
 /** Returns the content of the specified Compute Node file. */
@@ -424,7 +432,8 @@ export async function getNodeFile(
   options: GetNodeFileOptionalParams = { requestOptions: {} },
 ): Promise<GetNodeFileResponse> {
   const streamableMethod = _getNodeFileSend(context, poolId, nodeId, filePath, options);
-  return _getNodeFileDeserialize(streamableMethod);
+  const result = await getBinaryStreamResponse(streamableMethod);
+  return _getNodeFileDeserialize(result);
 }
 
 export function _deleteNodeFileSend(
@@ -822,9 +831,17 @@ export function _getNodeRemoteDesktopFileSend(
 }
 
 export async function _getNodeRemoteDesktopFileDeserialize(
-  result: StreamableMethod,
+  result: PathUncheckedResponse & GetNodeRemoteDesktopFileResponse,
 ): Promise<GetNodeRemoteDesktopFileResponse> {
-  return getBinaryResponseBody(result, ["200"], batchErrorDeserializer);
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = batchErrorDeserializer(result.body);
+
+    throw error;
+  }
+
+  return { blobBody: result.blobBody, readableStreamBody: result.readableStreamBody };
 }
 
 /**
@@ -840,7 +857,8 @@ export async function getNodeRemoteDesktopFile(
   options: GetNodeRemoteDesktopFileOptionalParams = { requestOptions: {} },
 ): Promise<GetNodeRemoteDesktopFileResponse> {
   const streamableMethod = _getNodeRemoteDesktopFileSend(context, poolId, nodeId, options);
-  return _getNodeRemoteDesktopFileDeserialize(streamableMethod);
+  const result = await getBinaryStreamResponse(streamableMethod);
+  return _getNodeRemoteDesktopFileDeserialize(result);
 }
 
 export function _getNodeRemoteLoginSettingsSend(
@@ -1655,9 +1673,17 @@ export function _getTaskFileSend(
 }
 
 export async function _getTaskFileDeserialize(
-  result: StreamableMethod,
+  result: PathUncheckedResponse & GetTaskFileResponse,
 ): Promise<GetTaskFileResponse> {
-  return getBinaryResponseBody(result, ["200"], batchErrorDeserializer);
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    const error = createRestError(result);
+    error.details = batchErrorDeserializer(result.body);
+
+    throw error;
+  }
+
+  return { blobBody: result.blobBody, readableStreamBody: result.readableStreamBody };
 }
 
 /** Returns the content of the specified Task file. */
@@ -1669,7 +1695,8 @@ export async function getTaskFile(
   options: GetTaskFileOptionalParams = { requestOptions: {} },
 ): Promise<GetTaskFileResponse> {
   const streamableMethod = _getTaskFileSend(context, jobId, taskId, filePath, options);
-  return _getTaskFileDeserialize(streamableMethod);
+  const result = await getBinaryStreamResponse(streamableMethod);
+  return _getTaskFileDeserialize(result);
 }
 
 export function _deleteTaskFileSend(

packages/typespec-test/test/batch_modular/generated/typespec-ts/src/static-helpers/serialization/get-binary-response-body-browser.mts

@@ -0,0 +1,23 @@
+import { HttpResponse, StreamableMethod } from "@azure-rest/core-client";
+
+/**
+ * Resolves a StreamableMethod into a binary stream response using browser streaming.
+ * Returns both the raw HttpResponse (for status/header inspection) and a blobBody Promise.
+ * Error handling is left to the caller so that generated deserializers can apply
+ * operation-specific error deserialization (per-status-code details, exception headers, etc.).
+ */
+export async function getBinaryStreamResponse(
+  streamableMethod: StreamableMethod
+): Promise<
+  HttpResponse & {
+    blobBody?: Promise<Blob>;
+    readableStreamBody?: NodeJS.ReadableStream;
+  }
+> {
+  const response = await streamableMethod.asBrowserStream();
+  return {
+    ...response,
+    blobBody: new Response(response.body).blob(),
+    readableStreamBody: undefined,
+  };
+}

packages/typespec-test/test/batch_modular/generated/typespec-ts/src/static-helpers/serialization/get-binary-response-body.ts

@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { HttpResponse, StreamableMethod } from "@azure-rest/core-client";
+
+/**
+ * Resolves a StreamableMethod into a binary stream response using Node.js streaming.
+ * Returns both the raw HttpResponse (for status/header inspection) and the readable stream body.
+ * Error handling is left to the caller so that generated deserializers can apply
+ * operation-specific error deserialization (per-status-code details, exception headers, etc.).
+ */
+export async function getBinaryStreamResponse(streamableMethod: StreamableMethod): Promise<
+  HttpResponse & {
+    blobBody?: Promise<Blob>;
+    readableStreamBody?: NodeJS.ReadableStream;
+  }
+> {
+  const response = await streamableMethod.asNodeStream();
+  return {
+    ...response,
+    blobBody: undefined,
+    readableStreamBody: response.body,
+  };
+}

packages/typespec-test/test/batch_modular/generated/typespec-ts/src/static-helpers/serialization/get-binary-stream-response-browser.mts

@@ -33,7 +33,7 @@ import {
   GetAudioTranslationAsPlainTextResponse,
   GetAudioTranscriptionAsPlainTextResponse,
 } from "../models/models.js";
-import { getBinaryResponseBody } from "../static-helpers/serialization/get-binary-response-body.js";
+import { getBinaryStreamResponse } from "../static-helpers/serialization/get-binary-stream-response.js";
 import { expandUrlTemplate } from "../static-helpers/urlTemplate.js";
 import {
   GetEmbeddingsOptionalParams,
@@ -128,9 +128,14 @@ export function _generateSpeechFromTextSend(
 }
 
 export async function _generateSpeechFromTextDeserialize(
-  result: StreamableMethod,
+  result: PathUncheckedResponse & GenerateSpeechFromTextResponse,
 ): Promise<GenerateSpeechFromTextResponse> {
-  return getBinaryResponseBody(result, ["200"]);
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    throw createRestError(result);
+  }
+
+  return { blobBody: result.blobBody, readableStreamBody: result.readableStreamBody };
 }
 
 /** Generates text-to-speech audio from the input text. */
@@ -141,7 +146,8 @@ export async function generateSpeechFromText(
   options: GenerateSpeechFromTextOptionalParams = { requestOptions: {} },
 ): Promise<GenerateSpeechFromTextResponse> {
   const streamableMethod = _generateSpeechFromTextSend(context, deploymentId, body, options);
-  return _generateSpeechFromTextDeserialize(streamableMethod);
+  const result = await getBinaryStreamResponse(streamableMethod);
+  return _generateSpeechFromTextDeserialize(result);
 }
 
 export function _getImageGenerationsSend(

packages/typespec-test/test/batch_modular/generated/typespec-ts/src/static-helpers/serialization/get-binary-stream-response.ts

@@ -0,0 +1,23 @@
+import { HttpResponse, StreamableMethod } from "@azure-rest/core-client";
+
+/**
+ * Resolves a StreamableMethod into a binary stream response using browser streaming.
+ * Returns both the raw HttpResponse (for status/header inspection) and a blobBody Promise.
+ * Error handling is left to the caller so that generated deserializers can apply
+ * operation-specific error deserialization (per-status-code details, exception headers, etc.).
+ */
+export async function getBinaryStreamResponse(
+  streamableMethod: StreamableMethod
+): Promise<
+  HttpResponse & {
+    blobBody?: Promise<Blob>;
+    readableStreamBody?: NodeJS.ReadableStream;
+  }
+> {
+  const response = await streamableMethod.asBrowserStream();
+  return {
+    ...response,
+    blobBody: new Response(response.body).blob(),
+    readableStreamBody: undefined,
+  };
+}

packages/typespec-test/test/openai_modular/generated/typespec-ts/src/api/operations.ts

@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { HttpResponse, StreamableMethod } from "@azure-rest/core-client";
+
+/**
+ * Resolves a StreamableMethod into a binary stream response using Node.js streaming.
+ * Returns both the raw HttpResponse (for status/header inspection) and the readable stream body.
+ * Error handling is left to the caller so that generated deserializers can apply
+ * operation-specific error deserialization (per-status-code details, exception headers, etc.).
+ */
+export async function getBinaryStreamResponse(streamableMethod: StreamableMethod): Promise<
+  HttpResponse & {
+    blobBody?: Promise<Blob>;
+    readableStreamBody?: NodeJS.ReadableStream;
+  }
+> {
+  const response = await streamableMethod.asNodeStream();
+  return {
+    ...response,
+    blobBody: undefined,
+    readableStreamBody: response.body,
+  };
+}