Add AILog.safeUnwrap static method to log on use of fallback values

Author: andrewheard

FirebaseAI/Sources/AILog.swift

@@ -65,6 +65,7 @@ enum AILog {
     case decodedUnsupportedPartData = 3014
     case codeExecutionResultUnrecognizedOutcome = 3015
     case executableCodeUnrecognizedLanguage = 3016
+    case fallbackValueUsed = 3017
 
     // SDK State Errors
     case generateContentResponseNoCandidates = 4000
@@ -126,4 +127,32 @@ enum AILog {
   static func additionalLoggingEnabled() -> Bool {
     return ProcessInfo.processInfo.arguments.contains(enableArgumentKey)
   }
+
+  /// Returns the unwrapped optional value if non-nil or returns the fallback value and logs.
+  ///
+  /// This convenience method is intended for use in place of `optionalValue ?? fallbackValue` with
+  /// the addition of logging on use of the fallback value.
+  ///
+  /// - Parameters:
+  ///   - optionalValue: The value to unwrap.
+  ///   - fallbackValue: The fallback (default) value to return when `optionalValue` is `nil`.
+  ///   - level: The logging level to use for fallback messages; defaults to
+  ///     `FirebaseLoggerLevel.warning`.
+  ///   - code: The message code to use for fallback messages; defaults to
+  ///     `MessageCode.fallbackValueUsed`.
+  ///   - caller: The name of the unwrapped value; defaults to the name of the computed property or
+  ///     function name from which the unwrapping occurred.
+  static func safeUnwrap<T>(_ optionalValue: T?,
+                            fallback fallbackValue: T,
+                            level: FirebaseLoggerLevel = .warning,
+                            code: MessageCode = .fallbackValueUsed,
+                            caller: String = #function) -> T {
+    guard let unwrappedValue = optionalValue else {
+      AILog.log(level: level, code: code, """
+      No value specified for '\(caller)' (\(T.self)); using fallback value '\(fallbackValue)'.
+      """)
+      return fallbackValue
+    }
+    return unwrappedValue
+  }
 }

FirebaseAI/Sources/Types/Public/Part.swift

@@ -229,14 +229,16 @@ public struct ExecutableCodePart: Part {
     ExecutableCodePart.Language(
       // Fallback to "LANGUAGE_UNSPECIFIED" if the value is ever omitted by the backend; this should
       // never happen.
-      executableCode.language ?? ExecutableCode.Language(kind: .unspecified)
+      AILog.safeUnwrap(
+        executableCode.language, fallback: ExecutableCode.Language(kind: .unspecified)
+      )
     )
   }
 
   /// The code that was executed.
   public var code: String {
     // Fallback to empty string if `code` is ever omitted by the backend; this should never happen.
-    executableCode.code ?? ""
+    AILog.safeUnwrap(executableCode.code, fallback: "")
   }
 
   public var isThought: Bool { _isThought ?? false }
@@ -290,15 +292,14 @@ public struct CodeExecutionResultPart: Part {
     CodeExecutionResultPart.Outcome(
       // Fallback to "OUTCOME_UNSPECIFIED" if this value is ever omitted by the backend; this should
       // never happen.
-      codeExecutionResult.outcome ?? CodeExecutionResult.Outcome(kind: .unspecified)
+      AILog.safeUnwrap(
+        codeExecutionResult.outcome, fallback: CodeExecutionResult.Outcome(kind: .unspecified)
+      )
     )
   }
 
   /// The output of the code execution.
-  public var output: String {
-    // Fallback to empty string if `output` is omitted by the backend; this should never happen.
-    codeExecutionResult.output ?? ""
-  }
+  public var output: String? { codeExecutionResult.output }
 
   public var isThought: Bool { _isThought ?? false }