Add Gemini image generation support (#117)

Author: lzell

README.md

@@ -1791,6 +1791,61 @@ Use the file URL returned from the snippet above.
     }
 ```
 
+### How to generate an image with Gemini
+
+```
+    import AIProxy
+
+    /* Uncomment for BYOK use cases */
+    // let geminiService = AIProxy.geminiDirectService(
+    //     unprotectedAPIKey: "your-gemini-key"
+    // )
+
+    /* Uncomment for all other production use cases */
+    // let geminiService = AIProxy.geminiService(
+    //     partialKey: "partial-key-from-your-developer-dashboard",
+    //     serviceURL: "service-url-from-your-developer-dashboard"
+    // )
+
+    let requestBody = GeminiGenerateContentRequestBody(
+        contents: [
+            .init(
+                parts: [
+                    .text(
+                        """
+                        Hi, can you create a 3d rendered image of a pig with wings and a top hat
+                        flying over a happy futuristic scifi city with lots of greenery?
+                        """
+                    )
+                ],
+                role: "user"
+            )
+        ],
+        generationConfig: .init(
+            responseModalities: [
+                "Text",
+                "Image"
+            ]
+        )
+    )
+
+    do {
+        let response = try await geminiService.generateContentRequest(
+            body: requestBody,
+            model: "gemini-2.0-flash-exp-image-generation"
+        )
+        for part in response.candidates?.first?.content?.parts ?? [] {
+            if case .inlineData(mimeType: let mimeType, base64Data: let base64Data) = part {
+                print("Gemini generated inline data with mimetype: \(mimeType) and base64Length: \(base64Data.count)")
+            }
+        }
+    } catch AIProxyError.unsuccessfulRequest(let statusCode, let responseBody) {
+        print("Received \(statusCode) status code with response body: \(responseBody)")
+    } catch {
+        print("Could not create image using gemini: \(error.localizedDescription)")
+    }
+```
+
 
 ***
 

Sources/AIProxy/Gemini/GeminiGenerateContentResponseBody.swift

@@ -65,21 +65,30 @@ extension GeminiGenerateContentResponseBody.Candidate.Content {
     public enum Part: Decodable {
         case text(String)
         case functionCall(name: String, args: [String: Any]?)
+        case inlineData(mimeType: String, base64Data: String)
 
         private enum CodingKeys: String, CodingKey {
             case text
             case functionCall
+            case inlineData
         }
 
         private struct _FunctionCall: Decodable {
             let name: String
             let args: [String: AIProxyJSONValue]?
         }
 
+        private struct _InlineData: Decodable {
+            let mimeType: String
+            let data: String
+        }
+
         public init(from decoder: any Decoder) throws {
             let container = try decoder.container(keyedBy: CodingKeys.self)
             if let functionCall = try container.decodeIfPresent(_FunctionCall.self, forKey: .functionCall) {
                 self = .functionCall(name: functionCall.name, args: functionCall.args?.untypedDictionary)
+            } else if let inlineData = try container.decodeIfPresent(_InlineData.self, forKey: .inlineData) {
+                self = .inlineData(mimeType: inlineData.mimeType, base64Data: inlineData.data)
             } else {
                 self = .text(try container.decode(String.self, forKey: .text))
             }

Tests/AIProxyTests/GeminiGenerateImageResponseTests.swift

@@ -0,0 +1,61 @@
+//
+//  GeminiGenerateImageResponseTests.swift
+//  AIProxy
+//
+//  Created by Lou Zell on 3/17/25.
+//
+
+import XCTest
+import Foundation
+@testable import AIProxy
+
+
+final class GeminiGenerateImageResponseTests: XCTestCase {
+
+    func testResponseIsDecodable() throws {
+        let sampleResponse = #"""
+        {
+          "candidates": [
+            {
+              "content": {
+                "parts": [
+                  {
+                    "inlineData": {
+                      "mimeType": "image/png",
+                      "data": "<snip>"
+                    }
+                  }
+                ],
+                "role": "model"
+              },
+              "finishReason": "STOP",
+              "index": 0
+            }
+          ],
+          "usageMetadata": {
+            "promptTokenCount": 36,
+            "totalTokenCount": 36,
+            "promptTokensDetails": [
+              {
+                "modality": "TEXT",
+                "tokenCount": 36
+              }
+            ]
+          },
+          "modelVersion": "gemini-2.0-flash-exp-image-generation"
+        }
+        """#
+
+        let body = try GeminiGenerateContentResponseBody.deserialize(from: sampleResponse)
+        if case .inlineData(mimeType: let mimeType, base64Data: let b64Data) = body.candidates?.first?.content?.parts?.first {
+            XCTAssertEqual("image/png", mimeType)
+            XCTAssertEqual("<snip>", b64Data)
+        } else {
+            XCTFail()
+        }
+    }
+
+}
+
+
+