Simplify ModelContent initializers.

The initialzer with `some PartsRepresentable` offers a strict subset of
the calls possible with the variadic parameter version.

The array of PartsRepresentable doesn't gain anything over the
variadic parameter version, and can actually lead to compiler
confusion and require awkward casting.

Author: ryanwilson

FirebaseVertexAI/Sources/ModelContent.swift

@@ -106,31 +106,6 @@ public struct ModelContent: Equatable, Sendable {
   // TODO: Refactor this
   let internalParts: [InternalPart]
 
-  /// Creates a new value from any data or `Array` of data interpretable as a
-  /// ``Part``. See ``PartsRepresentable`` for types that can be interpreted as `Part`s.
-  public init(role: String? = "user", parts: some PartsRepresentable) {
-    self.role = role
-    var convertedParts = [InternalPart]()
-    for part in parts.partsValue {
-      switch part {
-      case let textPart as TextPart:
-        convertedParts.append(.text(textPart.text))
-      case let inlineDataPart as InlineDataPart:
-        let inlineData = inlineDataPart.inlineData
-        convertedParts.append(.inlineData(mimetype: inlineData.mimeType, inlineData.data))
-      case let fileDataPart as FileDataPart:
-        let fileData = fileDataPart.fileData
-        convertedParts.append(.fileData(mimetype: fileData.mimeType, uri: fileData.fileURI))
-      case let functionCallPart as FunctionCallPart:
-        convertedParts.append(.functionCall(functionCallPart.functionCall))
-      case let functionResponsePart as FunctionResponsePart:
-        convertedParts.append(.functionResponse(functionResponsePart.functionResponse))
-      default:
-        fatalError()
-      }
-    }
-    internalParts = convertedParts
-  }
 
   /// Creates a new value from a list of ``Part``s.
   public init(role: String? = "user", parts: [any Part]) {
@@ -159,14 +134,7 @@ public struct ModelContent: Equatable, Sendable {
 
   /// Creates a new value from any data interpretable as a ``Part``.
   /// See ``PartsRepresentable`` for types that can be interpreted as `Part`s.
-  public init(role: String? = "user", _ parts: any PartsRepresentable...) {
-    let content = parts.flatMap { $0.partsValue }
-    self.init(role: role, parts: content)
-  }
-
-  /// Creates a new value from any data interpretable as a ``Part``.
-  /// See ``PartsRepresentable``for types that can be interpreted as `Part`s.
-  public init(role: String? = "user", _ parts: [PartsRepresentable]) {
+  public init(role: String? = "user", parts: any PartsRepresentable...) {
     let content = parts.flatMap { $0.partsValue }
     self.init(role: role, parts: content)
   }

FirebaseVertexAI/Tests/Unit/VertexAIAPITests.swift

@@ -106,8 +106,8 @@ final class VertexAIAPITests: XCTestCase {
       _ = try await genAI.generateContent([str, UIImage(), TextPart(str)])
       _ = try await genAI.generateContent(str, UIImage(), "def", UIImage())
       _ = try await genAI.generateContent([str, UIImage(), "def", UIImage()])
-      _ = try await genAI.generateContent([ModelContent("def", UIImage()),
-                                           ModelContent("def", UIImage())])
+    _ = try await genAI.generateContent([ModelContent(parts: "def", UIImage()),
+                                         ModelContent(parts: "def", UIImage())])
     #elseif canImport(AppKit)
       _ = try await genAI.generateContent(NSImage())
       _ = try await genAI.generateContent([NSImage()])
@@ -121,37 +121,31 @@ final class VertexAIAPITests: XCTestCase {
     let _ = ModelContent(parts: "Constant String")
     let _ = ModelContent(parts: str)
     let _ = ModelContent(parts: [str])
-    // Note: without `as [any PartsRepresentable]` this will fail to compile with "Cannot
-    // convert value of type 'String' to expected element type
-    // 'Array<Part>.ArrayLiteralElement'. Not sure if there's a way we can get it to
-    // work.
     let _ = ModelContent(
-      parts: [str, InlineDataPart(data: Data(), mimeType: "foo")] as [any PartsRepresentable]
+      parts: [str, InlineDataPart(inlineData: InlineData(
+        mimeType: "foo",
+        data: Data()
+      ))]
     )
     #if canImport(UIKit)
       _ = ModelContent(role: "user", parts: UIImage())
       _ = ModelContent(role: "user", parts: [UIImage()])
-      // Note: without `as [any PartsRepresentable]` this will fail to compile with "Cannot convert
-      // value of type `[Any]` to expected type `[any PartsRepresentable]`. Not sure if there's a
-      // way we can get it to work.
-      _ = ModelContent(parts: [str, UIImage()] as [any PartsRepresentable])
-      // Alternatively, you can explicitly declare the type in a variable and pass it in.
+      _ = ModelContent(parts: [str, UIImage()])
+      // Note: without explicitly specifying`: [any PartsRepresentable]` this will fail to compile
+      // below with "Cannot convert value of type `[Any]` to expected type `[any Part]`.
       let representable2: [any PartsRepresentable] = [str, UIImage()]
       _ = ModelContent(parts: representable2)
-      _ =
-        ModelContent(parts: [str, UIImage(), TextPart(str)] as [any PartsRepresentable])
+      _ = ModelContent(parts: [str, UIImage(), TextPart(str)])
     #elseif canImport(AppKit)
       _ = ModelContent(role: "user", parts: NSImage())
       _ = ModelContent(role: "user", parts: [NSImage()])
-      // Note: without `as [any PartsRepresentable]` this will fail to compile with "Cannot convert
-      // value of type `[Any]` to expected type `[any PartsRepresentable]`. Not sure if there's a
-      // way we can get it to work.
-      _ = ModelContent(parts: [str, NSImage()] as [any PartsRepresentable])
-      // Alternatively, you can explicitly declare the type in a variable and pass it in.
+      _ = ModelContent(parts: [str, NSImage()])
+      // Note: without explicitly specifying`: [any PartsRepresentable]` this will fail to compile
+      // below with "Cannot convert value of type `[Any]` to expected type `[any Part]`.
       let representable2: [any PartsRepresentable] = [str, NSImage()]
       _ = ModelContent(parts: representable2)
       _ =
-        ModelContent(parts: [str, NSImage(), TextPart(str)] as [any PartsRepresentable])
+        ModelContent(parts: [str, NSImage(), TextPart(str)])
     #endif
 
     // countTokens API
@@ -160,8 +154,8 @@ final class VertexAIAPITests: XCTestCase {
       let _: CountTokensResponse = try await genAI.countTokens("What color is the Sky?",
                                                                UIImage())
       let _: CountTokensResponse = try await genAI.countTokens([
-        ModelContent("What color is the Sky?", UIImage()),
-        ModelContent(UIImage(), "What color is the Sky?", UIImage()),
+        ModelContent(parts: "What color is the Sky?", UIImage()),
+        ModelContent(parts: UIImage(), "What color is the Sky?", UIImage()),
       ])
     #endif