[TCGC] Support multipart response and fix multipart anonymous model naming empty.

.chronus/changes/fix_multipart-2025-7-1-16-32-10.md

@@ -0,0 +1,7 @@
+---
+changeKind: fix
+packages:
+  - "@azure-tools/typespec-client-generator-core"
+---
+
+Support multipart response and fix multipart anonymous model naming empty.

packages/typespec-client-generator-core/src/internal-utils.ts

@@ -413,12 +413,6 @@ export function isContentTypeHeader(param: SdkHeaderParameter): boolean {
   return param.kind === "header" && param.serializedName.toLowerCase() === "content-type";
 }
 
-export function isMultipartOperation(context: TCGCContext, operation?: Operation): boolean {
-  if (!operation) return false;
-  const httpOperation = getHttpOperationWithCache(context, operation);
-  return httpOperation.parameters.body?.bodyKind === "multipart";
-}
-
 export function isHttpOperation(context: TCGCContext, obj: any): obj is HttpOperation {
   return obj?.kind === "Operation" && getHttpOperationWithCache(context, obj) !== undefined;
 }

packages/typespec-client-generator-core/src/public-utils.ts

@@ -395,6 +395,19 @@ function getContextPath(
       if (dfsModelProperties(typeToFind, bodyType, "Request")) {
         return result;
       }
+
+      if (httpOperation.parameters.body.bodyKind === "multipart") {
+        for (const part of httpOperation.parameters.body.parts) {
+          visited.clear();
+          result = [{ name: root.name, type: root }];
+          if (
+            part.partKind === "model" &&
+            dfsModelProperties(typeToFind, part.body.type, `Request${pascalCase(part.name)}`)
+          ) {
+            return result;
+          }
+        }
+      }
     }
 
     for (const parameter of Object.values(httpOperation.parameters.parameters)) {
@@ -415,6 +428,19 @@ function getContextPath(
           if (dfsModelProperties(typeToFind, innerResponse.body.type, "Response", true)) {
             return result;
           }
+
+          if (innerResponse.body?.bodyKind === "multipart") {
+            for (const part of innerResponse.body.parts) {
+              visited.clear();
+              result = [{ name: root.name, type: root }];
+              if (
+                part.partKind === "model" &&
+                dfsModelProperties(typeToFind, part.body.type, `Request${pascalCase(part.name)}`)
+              ) {
+                return result;
+              }
+            }
+          }
         }
 
         const headers = getHttpOperationResponseHeaders(innerResponse);

packages/typespec-client-generator-core/src/types.ts

@@ -34,6 +34,7 @@ import {
 } from "@typespec/compiler";
 import {
   Authentication,
+  HttpOperationMultipartBody,
   Visibility,
   getAuthentication,
   getServers,
@@ -98,7 +99,6 @@ import {
   hasNoneVisibility,
   intOrFloat,
   isHttpBodySpread,
-  isMultipartOperation,
   isNeverOrVoidType,
   isOnClient,
   listAllUserDefinedNamespaces,
@@ -837,11 +837,30 @@ export function getSdkModelWithDiagnostics(
     }
 
     // properties should be generated first since base model's discriminator handling is depend on derived model's properties
-    if (operation && isMultipartOperation(context, operation)) {
-      const body = getHttpOperationWithCache(context, operation).parameters.body;
-      if (body && getHttpBodyType(body) === type) {
-        // handle multipart body model properties
-        diagnostics.pipe(addMultipartPropertiesToModelType(context, sdkType, operation));
+    if (operation) {
+      const requestBody = getHttpOperationWithCache(context, operation).parameters.body;
+      const multipartResponseBodies = getHttpOperationWithCache(context, operation)
+        .responses.map((response) => response.responses.map((r) => r.body))
+        .flatMap((x) => x)
+        .filter((x) => x?.bodyKind === "multipart");
+      if (
+        requestBody &&
+        requestBody.bodyKind === "multipart" &&
+        getHttpBodyType(requestBody) === type
+      ) {
+        // handle multipart request body model properties
+        diagnostics.pipe(
+          addMultipartPropertiesToModelType(context, sdkType, requestBody, operation),
+        );
+      } else if (multipartResponseBodies.length > 0) {
+        // handle multipart response body model properties
+        multipartResponseBodies.map((body) =>
+          getHttpBodyType(body) === type
+            ? diagnostics.pipe(
+                addMultipartPropertiesToModelType(context, sdkType!, body, operation),
+              )
+            : undefined,
+        );
       } else {
         // handle normal model properties
         diagnostics.pipe(addPropertiesToModelType(context, type, sdkType, operation));
@@ -1310,13 +1329,10 @@ function addPropertiesToModelType(
 function addMultipartPropertiesToModelType(
   context: TCGCContext,
   sdkType: SdkModelType,
+  body: HttpOperationMultipartBody,
   operation: Operation,
 ): [void, readonly Diagnostic[]] {
   const diagnostics = createDiagnosticCollector();
-  const body = getHttpOperationWithCache(context, operation).parameters.body;
-  if (!body || body.bodyKind !== "multipart") {
-    return diagnostics.wrap(undefined);
-  }
   for (const part of body.parts) {
     const clientProperty = diagnostics.pipe(
       getSdkModelPropertyType(context, part.property!, operation),
@@ -1558,7 +1574,7 @@ function updateTypesFromOperation(
       getClientTypeWithDiagnostics(context, getHttpBodyType(httpBody), operation),
     );
 
-    const multipartOperation = isMultipartOperation(context, operation);
+    const multipartRequest = httpBody.bodyKind === "multipart";
     if (generateConvenient) {
       if (spread && sdkType.kind === "model") {
         updateUsageOrAccess(context, UsageFlags.Spread, sdkType, { propagation: false });
@@ -1576,7 +1592,7 @@ function updateTypesFromOperation(
         // will also have Json type
         diagnostics.pipe(updateUsageOrAccess(context, UsageFlags.JsonMergePatch, sdkType));
       }
-      if (multipartOperation) {
+      if (multipartRequest) {
         diagnostics.pipe(
           updateUsageOrAccess(context, UsageFlags.MultipartFormData, sdkType, {
             propagation: false,
@@ -1593,7 +1609,7 @@ function updateTypesFromOperation(
         const isUsedInMultipart = (sdkType.usage & UsageFlags.MultipartFormData) > 0;
         const isUsedInOthers =
           ((sdkType.usage & UsageFlags.Json) | (sdkType.usage & UsageFlags.Xml)) > 0;
-        if ((!multipartOperation && isUsedInMultipart) || (multipartOperation && isUsedInOthers)) {
+        if ((!multipartRequest && isUsedInMultipart) || (multipartRequest && isUsedInOthers)) {
           // This means we have a model that is used both for formdata input and for regular body input
           diagnostics.add(
             createDiagnostic({
@@ -1634,6 +1650,18 @@ function updateTypesFromOperation(
             diagnostics.pipe(updateUsageOrAccess(context, UsageFlags.Json, sdkType));
           }
 
+          if (innerResponse.body.contentTypes.some((x) => isMediaTypeXml(x))) {
+            diagnostics.pipe(updateUsageOrAccess(context, UsageFlags.Xml, sdkType));
+          }
+
+          if (innerResponse.body.bodyKind === "multipart") {
+            diagnostics.pipe(
+              updateUsageOrAccess(context, UsageFlags.MultipartFormData, sdkType, {
+                propagation: false,
+              }),
+            );
+          }
+
           // add serialization options to model type
           updateSerializationOptions(context, sdkType, innerResponse.body.contentTypes);
         }

packages/typespec-client-generator-core/test/types/multipart.test.ts

@@ -785,3 +785,83 @@ it("check header in multipart with @multipartBody for model", async function ()
   strictEqual(prop.serializationOptions.multipart.headers.length, 1);
   strictEqual(prop.multipartOptions, prop.serializationOptions.multipart);
 });
+
+it("multipart response", async function () {
+  await runner.compileWithBuiltInService(`
+    @route("/downloadFile")
+    @post
+    op downloadFile(): {
+      @header contentType: "multipart/form-data";
+      @multipartBody body: {
+        name: HttpPart<string>;
+        file: HttpPart<bytes>[];
+      };
+    };
+  `);
+
+  const models = runner.context.sdkPackage.models;
+  strictEqual(models.length, 1);
+  const model = models[0];
+  strictEqual(model.kind, "model");
+  ok((model.usage & UsageFlags.MultipartFormData) > 0);
+  strictEqual(model.name, "DownloadFileResponse");
+  strictEqual(model.properties.length, 2);
+  const name = model.properties.find((x) => x.name === "name");
+  ok(name);
+  strictEqual(name.kind, "property");
+  strictEqual(name.type.kind, "string");
+  strictEqual(name.serializationOptions.multipart?.headers.length, 0);
+  const file = model.properties.find((x) => x.name === "file");
+  ok(file);
+  strictEqual(file.kind, "property");
+  ok(file.serializationOptions.multipart);
+  strictEqual(file.serializationOptions.multipart.isFilePart, true);
+  strictEqual(file.isMultipartFileInput, true);
+  strictEqual(file.multipartOptions, file.serializationOptions.multipart);
+});
+
+it("multipart with visibility", async function () {
+  await runner.compileWithBuiltInService(`
+    model TodoItem {
+      @visibility(Lifecycle.Read) @key id: safeint;
+      @maxLength(255)
+      title: string;
+      @visibility(Lifecycle.Read) createdBy: string;
+      assignedTo?: string;
+      description?: string;
+      status: "NotStarted" | "InProgress" | "Completed";
+      @visibility(Lifecycle.Read) createdAt: utcDateTime;
+      @visibility(Lifecycle.Read) updatedAt: utcDateTime;
+      @visibility(Lifecycle.Read) completedAt?: utcDateTime;
+      labels?: string[];
+      @visibility(Lifecycle.Create) dummy?: string;
+    }
+
+    op try(@header contentType: "multipart/form-data",
+        @multipartBody body: {
+      item: HttpPart<TodoItem>;
+    }): void;
+  `);
+
+  const models = runner.context.sdkPackage.models;
+  strictEqual(models.length, 2);
+  const model = models[0];
+  strictEqual(model.kind, "model");
+  ok((model.usage & UsageFlags.MultipartFormData) > 0);
+  strictEqual(model.name, "TryRequest");
+  strictEqual(model.properties.length, 1);
+  const item = model.properties.find((x) => x.name === "item");
+  ok(item);
+  strictEqual(item.kind, "property");
+  strictEqual(item.type.kind, "model");
+  strictEqual(item.serializationOptions.multipart?.headers.length, 0);
+  strictEqual(item.serializationOptions.multipart?.isFilePart, false);
+  strictEqual(item.serializationOptions.multipart?.defaultContentTypes.length, 1);
+  strictEqual(item.serializationOptions.multipart.defaultContentTypes[0], "application/json");
+
+  const todoItem = models[1];
+  ok(todoItem);
+  strictEqual(todoItem.kind, "model");
+  strictEqual(todoItem.name, "TryRequestItem");
+  strictEqual(todoItem.properties.length, 6);
+});