Gemini 3.2 Pro の Function Calling を iOS/Android アプリに統合する実装パターン

import Foundation
import Combine
 
class WallpaperAIService: ObservableObject {
    private let backendURL = "https://your-api.example.com/chat"
    @Published var isLoading = false
    @Published var recommendations: [WallpaperItem] = []
    @Published var errorMessage: String?
 
    func requestRecommendations(userMessage: String, userId: String) async {
        await MainActor.run { isLoading = true; errorMessage = nil }
 
        let requestBody: [String: Any] = ["message": userMessage, "user_id": userId]
        guard let url = URL(string: backendURL),
              let body = try? JSONSerialization.data(withJSONObject: requestBody) else {
            await MainActor.run { errorMessage = "リクエストの準備に失敗しました"; isLoading = false }
            return
        }
 
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = body
        // Function Calling はモデル推論→関数実行→再度モデルへ送信のサイクルがあるため
        // タイムアウトを通常より長めに設定する（30秒は最低ライン）
        request.timeoutInterval = 30.0
 
        do {
            let (data, response) = try await URLSession.shared.data(for: request)
            guard let httpResponse = response as? HTTPURLResponse,
                  httpResponse.statusCode == 200 else {
                throw URLError(.badServerResponse)
            }
            let result = try JSONDecoder().decode(WallpaperRecommendationResponse.self, from: data)
            await MainActor.run {
                self.recommendations = result.wallpapers
                self.isLoading = false
            }
        } catch {
            await MainActor.run {
                // リトライ可能なエラーと不可能なエラーを UI レベルで区別する
                if let urlError = error as? URLError,
                   urlError.code == .timedOut || urlError.code == .networkConnectionLost {
                    self.errorMessage = "接続が不安定です。もう一度お試しください"
                } else {
                    self.errorMessage = "取得できませんでした"
                }
                self.isLoading = false
            }
        }
    }
}
 
struct WallpaperAIView: View {
    @StateObject private var service = WallpaperAIService()
    @State private var userInput = ""
    let userId: String
 
    var body: some View {
        VStack(spacing: 16) {
            HStack {
                TextField("どんな壁紙をお探しですか？", text: $userInput)
                    .textFieldStyle(.roundedBorder)
                Button("検索") {
                    Task {
                        await service.requestRecommendations(userMessage: userInput, userId: userId)
                    }
                }
                .disabled(userInput.isEmpty || service.isLoading)
            }
            .padding(.horizontal)
            if service.isLoading {
                VStack(spacing: 8) {
                    ProgressView()
                    Text("AIが好みを分析中...")
                        .font(.caption).foregroundColor(.secondary)
                }
                .padding()
            }
            if let error = service.errorMessage {
                Text(error).foregroundColor(.red).font(.caption).padding()
            }
            ScrollView {
                LazyVGrid(columns: [GridItem(.flexible()), GridItem(.flexible())], spacing: 12) {
                    ForEach(service.recommendations) { item in
                        WallpaperThumbnailView(item: item)
                    }
                }
                .padding()
            }
        }
    }
}

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.request.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch
import kotlinx.serialization.Serializable
 
@Serializable
data class WallpaperRequest(val message: String, val userId: String)
 
@Serializable
data class WallpaperItem(
    val id: String, val title: String,
    val imageUrl: String, val style: String, val mood: String
)
 
@Serializable
data class RecommendationResponse(val wallpapers: List<WallpaperItem>, val message: String)
 
class WallpaperAIViewModel : ViewModel() {
    private val client = HttpClient {
        install(ContentNegotiation) { json() }
    }
 
    private val _recommendations = MutableStateFlow<List<WallpaperItem>>(emptyList())
    val recommendations: StateFlow<List<WallpaperItem>> = _recommendations
 
    sealed class UiState {
        object Idle : UiState()
        object Loading : UiState()
        data class Success(val message: String) : UiState()
        data class Error(val message: String, val isRetryable: Boolean) : UiState()
    }
 
    private val _uiState = MutableStateFlow<UiState>(UiState.Idle)
    val uiState: StateFlow<UiState> = _uiState
 
    fun fetchRecommendations(userMessage: String, userId: String) {
        viewModelScope.launch {
            _uiState.value = UiState.Loading
            var lastError: Exception? = null
 
            // 指数バックオフによるリトライ（0.5秒 → 1秒 → 2秒）
            repeat(3) { attempt ->
                try {
                    val response: RecommendationResponse =
                        client.post("https://your-api.example.com/chat") {
                            contentType(io.ktor.http.ContentType.Application.Json)
                            setBody(WallpaperRequest(message = userMessage, userId = userId))
                            timeout {
                                requestTimeoutMillis = 30_000
                                connectTimeoutMillis = 10_000
                            }
                        }.body()
                    _recommendations.value = response.wallpapers
                    _uiState.value = UiState.Success(response.message)
                    return@launch
                } catch (e: Exception) {
                    lastError = e
                    if (attempt < 2) delay(500L * (1 shl attempt))
                }
            }
 
            val isRetryable = lastError?.message?.let {
                it.contains("timeout", ignoreCase = true) ||
                it.contains("connection", ignoreCase = true)
            } ?: false
            _uiState.value = UiState.Error(
                message = if (isRetryable) "接続が不安定です" else "取得できませんでした",
                isRetryable = isRetryable
            )
        }
    }
 
    override fun onCleared() { super.onCleared(); client.close() }
}

# 連鎖呼び出しを強制する設定
model = genai.GenerativeModel(
    model_name="gemini-3.2-pro",
    tools=tools,
    tool_config={
        "function_calling_config": {
            "mode": "ANY",  # テキスト回答を禁止して必ず関数を呼ばせる
            "allowed_function_names": [
                "get_user_preferences", "filter_wallpapers", "get_wallpaper_details"
            ]
        }
    }
)

import google.generativeai as genai
 
genai.configure(api_key="YOUR_GEMINI_API_KEY")
 
# 期待されるルーティング（入力フレーズ → 呼ばれるべき関数名の集合）
ROUTING_CASES = [
    {"input": "落ち着く壁紙を見せて",
     "expect_any": {"filter_wallpapers"}},
    {"input": "いつも見てる系統で、まだ見てないやつ",
     "expect_all": {"get_user_preferences", "filter_wallpapers"}},
    {"input": "この機能の使い方を教えて",
     "expect_none": True},  # 一般的な質問では関数を呼ばないのが正しい
]
 
def called_functions(user_message: str) -> set:
    chat = model.start_chat()
    response = chat.send_message(user_message)
    return {
        part.function_call.name
        for part in response.candidates[0].content.parts
        if hasattr(part, "function_call") and part.function_call
    }
 
def run_routing_regression() -> int:
    failures = 0
    for case in ROUTING_CASES:
        called = called_functions(case["input"])
        if case.get("expect_none"):
            ok = len(called) == 0
        elif "expect_all" in case:
            ok = case["expect_all"].issubset(called)
        else:
            ok = bool(case["expect_any"] & called)
        if not ok:
            failures += 1
        print(f"[{'OK' if ok else 'FAIL'}] {case['input']} -> {called or '(no call)'}")
    return failures
 
if __name__ == "__main__":
    import sys
    # 1 件でも期待と違えば CI を落とす
    sys.exit(1 if run_routing_regression() else 0)

# preflight.py — 回帰テストの前に「届くかどうか」を確かめる
import os
import sys
import requests
 
MODEL = "gemini-3.2-pro"
ENDPOINT = f"https://generativelanguage.googleapis.com/v1beta/models/{MODEL}:generateContent"
 
def credential_kind(value: str) -> str:
    """環境変数に入っている資格情報の系統を判定します。"""
    if not value:
        return "missing"
    if value.lstrip().startswith("{") or value.rstrip().endswith(".json"):
        return "service_account"   # auth キー（サービスアカウント）
    return "legacy_api_key"        # 9 月中に停止する旧形式
 
def probe(access_token: str) -> tuple:
    """最小のリクエストを 1 回だけ投げ、失敗の理由を分類して返します。"""
    body = {
        "contents": [{"parts": [{"text": "ping"}]}],
        "generationConfig": {"maxOutputTokens": 1},
    }
    res = requests.post(
        ENDPOINT, json=body,
        headers={"Authorization": f"Bearer {access_token}"}, timeout=20,
    )
    if res.ok:
        return "ok", res.json().get("modelVersion", "(unknown)")
    reason = {401: "auth", 403: "permission", 404: "model_missing", 429: "rate_limited"}
    return reason.get(res.status_code, "other"), f"HTTP {res.status_code}"
 
if __name__ == "__main__":
    raw = os.environ.get("GEMINI_CREDENTIAL", "")
    kind = credential_kind(raw)
    print(f"credential = {kind}")
    if kind != "service_account":
        # 終了コード 2 は「土台の問題」。ルーティングの失敗（1）と混ぜません
        print("旧形式の資格情報です。移行してから回帰テストを回してください")
        sys.exit(2)
    status, detail = probe(access_token_from_service_account(raw))
    print(f"probe = {status} / {detail}")
    sys.exit(0 if status == "ok" else 2)