review

Author: paulb777

FirebaseAI/Sources/GenerationConfig.swift

@@ -205,11 +205,9 @@ public struct GenerationConfig: Sendable {
   }
 
   /// Internal initializer to create a new config by overriding specific values of another.
-  internal init(
-    from base: GenerationConfig?,
-    responseMIMEType: String,
-    responseSchema: Schema
-  ) {
+  init(from base: GenerationConfig?,
+       responseMIMEType: String,
+       responseSchema: Schema) {
     self.init(
       temperature: base?.temperature,
       topP: base?.topP,

FirebaseAI/Sources/GenerativeAIService.swift

@@ -28,7 +28,7 @@ struct GenerativeAIService {
 
   let firebaseInfo: FirebaseInfo
 
-  private let urlSession: URLSession
+  let urlSession: URLSession
 
   init(firebaseInfo: FirebaseInfo, urlSession: URLSession) {
     self.firebaseInfo = firebaseInfo

FirebaseAI/Sources/GenerativeModel+GenerateObject.swift

@@ -37,18 +37,7 @@ public extension GenerativeModel {
     )
 
     // Create a new model instance with the overridden config.
-    let model = GenerativeModel(
-      modelName: modelName,
-      modelResourceName: modelResourceName,
-      firebaseInfo: generativeAIService.firebaseInfo,
-      apiConfig: apiConfig,
-      generationConfig: newGenerationConfig,
-      safetySettings: safetySettings,
-      tools: tools,
-      toolConfig: toolConfig,
-      systemInstruction: systemInstruction,
-      requestOptions: requestOptions
-    )
+    let model = GenerativeModel(copying: self, generationConfig: newGenerationConfig)
     let response = try await model.generateContent(prompt)
 
     guard let text = response.text, let data = text.data(using: .utf8) else {

FirebaseAI/Sources/GenerativeModel.swift

@@ -118,6 +118,24 @@ public final class GenerativeModel: Sendable {
     AILog.debug(code: .generativeModelInitialized, "Model \(modelResourceName) initialized.")
   }
 
+  /// Internal initializer to create a new model by copying an existing one with specific overrides.
+  convenience init(copying other: GenerativeModel,
+                   generationConfig: GenerationConfig? = nil) {
+    self.init(
+      modelName: other.modelName,
+      modelResourceName: other.modelResourceName,
+      firebaseInfo: other.generativeAIService.firebaseInfo,
+      apiConfig: other.apiConfig,
+      generationConfig: generationConfig ?? other.generationConfig,
+      safetySettings: other.safetySettings,
+      tools: other.tools,
+      toolConfig: other.toolConfig,
+      systemInstruction: other.systemInstruction,
+      requestOptions: other.requestOptions,
+      urlSession: other.generativeAIService.urlSession
+    )
+  }
+
   /// Generates content from String and/or image inputs, given to the model as a prompt, that are
   /// representable as one or more ``Part``s.
   ///

FirebaseAI/Sources/Types/Public/Schema.swift

@@ -515,6 +515,7 @@ public extension Schema {
   /// `userSchema.nullable()`.
   ///
   /// - Returns: A new `Schema` instance with `nullable` set to `true`.
-    func asNullable() -> Schema {
-      return Schema(copying: self, nullable: true)
-    }}
+  func asNullable() -> Schema {
+    return Schema(copying: self, nullable: true)
+  }
+}

FirebaseAI/Tests/TestApp/Tests/Integration/GenerateContentIntegrationTests.swift

@@ -315,7 +315,9 @@ struct GenerateContentIntegrationTests {
             "Caught GenerateContentError, but it was not a responseStoppedEarly error with maxTokens reason."
           )
       }
-    } catch {}
+    } catch {
+      Issue.record("Function threw an unexpected error type: \(error)")
+    }
   }
 
   // A dessert with optional properties for testing nullable schema generation.

FirebaseAILogicMacros/Sources/FirebaseAILogicMacro/FirebaseGenerableMacro.swift

@@ -24,15 +24,34 @@ public struct FirebaseGenerableMacro: MemberMacro, ExtensionMacro {
     -> [SwiftSyntax.DeclSyntax]
     where Declaration: SwiftSyntax.DeclGroupSyntax,
     Context: SwiftSyntaxMacros.MacroExpansionContext {
-    let properties = declaration.memberBlock.members.compactMap {
-      $0.decl.as(VariableDeclSyntax.self)
-    }
+    // 1. Get all variable declarations from the member block.
+    let varDecls = declaration.memberBlock.members
+      .compactMap { $0.decl.as(VariableDeclSyntax.self) }
 
-    let schemaProperties: [String] = try properties.map { property in
-      let (name, type) = try property.toNameAndType()
-      return try """
-      "\(name)": \(schema(for: type))
-      """
+    // 2. Process each declaration to extract schema properties from its bindings.
+    let schemaProperties = try varDecls.flatMap { varDecl -> [String] in
+      // For declarations like `let a, b: String`, the type annotation is on the last binding.
+      let typeAnnotationFromDecl = varDecl.bindings.last?.typeAnnotation
+
+      return try varDecl.bindings.compactMap { binding -> String? in
+        // 3. Filter out computed properties. Stored properties do not have a getter/setter block.
+        guard binding.accessorBlock == nil else {
+          return nil
+        }
+
+        // 4. Get the property's name. Skip complex patterns like tuples.
+        guard let name = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier.text else {
+          return nil
+        }
+
+        // 5. Determine the property's type. It can be on the binding itself or on the declaration.
+        guard let type = binding.typeAnnotation?.type ?? typeAnnotationFromDecl?.type else {
+          throw MacroError.missingExplicitType(for: name)
+        }
+
+        // 6. Generate the schema string for this property.
+        return try "\"\(name)\": \(schema(for: type))"
+      }
     }
 
     return [
@@ -106,29 +125,16 @@ public struct FirebaseGenerableMacro: MemberMacro, ExtensionMacro {
   }
 }
 
-private extension VariableDeclSyntax {
-  func toNameAndType() throws -> (String, TypeSyntax) {
-    guard let binding = bindings.first else {
-      throw MacroError.unsupportedType(Syntax(self))
-    }
-    guard let name = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier.text else {
-      throw MacroError.unsupportedType(Syntax(self))
-    }
-    guard let type = binding.typeAnnotation?.type else {
-      throw MacroError.unsupportedType(Syntax(self))
-    }
-
-    return (name, type)
-  }
-}
-
 private enum MacroError: Error, CustomStringConvertible {
   case unsupportedType(Syntax)
+  case missingExplicitType(for: String)
 
   var description: String {
     switch self {
-    case let .unsupportedType(type):
-      return "Unsupported type: \(type)"
+    case let .unsupportedType(syntax):
+      return "Unsupported type syntax: \(syntax)"
+    case let .missingExplicitType(name):
+      return "Property '\(name)' must have an explicit type annotation to be used with @FirebaseGenerable."
     }
   }
 }

FirebaseAILogicMacros/Tests/FirebaseAILogicMacroTests/FirebaseAILogicMacroTests.swift

@@ -47,6 +47,34 @@ final class FirebaseGenerableMacroTests: XCTestCase {
     extension MyDessert: FirebaseAILogic.FirebaseGenerable {}
     """
 
+    assertMacroExpansion(originalSource, expandedSource: expectedSource, macros: macros)
+  func testExpansion_handlesMultiBindingAndComputedProperties() {
+    let originalSource = """
+    @FirebaseGenerable
+    struct MyType: Decodable {
+      let a, b: String
+      let c: Int
+      var isComputed: Bool { return true }
+    }
+    """
+
+    let expectedSource = """
+    struct MyType: Decodable {
+      let a, b: String
+      let c: Int
+      var isComputed: Bool { return true }
+      public static var firebaseGenerationSchema: FirebaseAILogic.Schema {
+        .object(properties: [
+          "a": FirebaseAILogic.Schema.string(),
+          "b": FirebaseAILogic.Schema.string(),
+          "c": FirebaseAILogic.Schema.integer()
+        ])
+      }
+    }
+
+    extension MyType: FirebaseAILogic.FirebaseGenerable {}
+    """
+
     assertMacroExpansion(originalSource, expandedSource: expectedSource, macros: macros)
   }
 }