Rork が二つのネイティブアプリに分かれたあと、AI の判断を残す側と寄せる側の線引き

// worker/src/ai-decision.ts
// 二つのネイティブアプリが「同じ答え」を受け取るための唯一の判断点。
// クライアントは決めません。受け取って従うだけにします。
 
export interface Env {
  AI_POLICY: KVNamespace;            // 方針そのもの（版つき）
  USAGE: DurableObjectNamespace;     // 利用量の数え上げ
}
 
type Reason =
  | 'ok'
  | 'quota_exceeded'
  | 'region_blocked'
  | 'feature_disabled'
  | 'policy_unavailable';
 
interface Decision {
  policy_version: string;  // 両クライアントのログに必ず載せる値
  allow: boolean;
  reason: Reason;
  remaining: number;       // 今日あと何回呼べるか
  model: string | null;    // 止めるときは null
  ttl_seconds: number;     // 次の問い合わせまで待ってよい秒数
}
 
// 方針が読めないときに返す既定値。
// allow: false に倒しておくのが肝心で、ここを true にすると
// 障害のあいだだけ全端末が無制限に呼べる状態になります。
const CLOSED: Decision = {
  policy_version: 'unknown',
  allow: false,
  reason: 'policy_unavailable',
  remaining: 0,
  model: null,
  ttl_seconds: 30,
};
 
export default {
  async fetch(req: Request, env: Env): Promise<Response> {
    if (req.method !== 'POST') {
      return json({ ...CLOSED, reason: 'feature_disabled' }, 405);
    }
 
    let body: { user_id?: string; feature?: string; region?: string };
    try {
      body = await req.json();
    } catch {
      return json({ ...CLOSED, reason: 'feature_disabled' }, 400);
    }
 
    const userId = body.user_id;
    const feature = body.feature;
    if (!userId || !feature) {
      return json({ ...CLOSED, reason: 'feature_disabled' }, 400);
    }
 
    let policy: {
      version: string;
      enabled: boolean;
      daily_limit: number;
      model: string;
      blocked_regions: string[];
    } | null = null;
 
    try {
      policy = await env.AI_POLICY.get(`policy:${feature}`, 'json');
    } catch {
      policy = null; // KV が読めない場合も閉じる側へ倒します
    }
    if (!policy) return json(CLOSED, 200);
 
    if (!policy.enabled) {
      return json(
        { ...CLOSED, policy_version: policy.version, reason: 'feature_disabled', ttl_seconds: 300 },
        200,
      );
    }
 
    const region = (body.region ?? '').toUpperCase();
    if (region && policy.blocked_regions.includes(region)) {
      return json(
        { ...CLOSED, policy_version: policy.version, reason: 'region_blocked', ttl_seconds: 3600 },
        200,
      );
    }
 
    // 利用量は Durable Object で一箇所に数えます。
    // クライアント側の端末ごとのカウンタは、機種変更と再インストールで簡単に巻き戻ります。
    const id = env.USAGE.idFromName(`${feature}:${userId}`);
    const used = await env.USAGE.get(id)
      .fetch('https://usage/increment', { method: 'POST' })
      .then((r) => r.json<{ count: number }>())
      .catch(() => null);
 
    if (!used) return json({ ...CLOSED, policy_version: policy.version }, 200);
 
    const remaining = Math.max(0, policy.daily_limit - used.count);
    const allow = remaining > 0;
 
    return json(
      {
        policy_version: policy.version,
        allow,
        reason: allow ? 'ok' : 'quota_exceeded',
        remaining,
        model: allow ? policy.model : null,
        ttl_seconds: allow ? 60 : 900,
      },
      200,
    );
  },
};
 
function json(d: Decision, status: number): Response {
  return new Response(JSON.stringify(d), {
    status,
    headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' },
  });
}

// AIDecisionClient.swift
// 判断は持ちません。受け取った封筒に従うだけにします。
 
import Foundation
 
struct AIDecision: Decodable {
    let policyVersion: String
    let allow: Bool
    let reason: String
    let remaining: Int
    let model: String?
    let ttlSeconds: Int
 
    enum CodingKeys: String, CodingKey {
        case policyVersion = "policy_version"
        case allow, reason, remaining, model
        case ttlSeconds = "ttl_seconds"
    }
 
    // 通信できなかったときに使う値。サーバ側の CLOSED と必ず同じ意味にします。
    static let closed = AIDecision(
        policyVersion: "unknown", allow: false, reason: "policy_unavailable",
        remaining: 0, model: nil, ttlSeconds: 30
    )
}
 
actor AIDecisionClient {
    private let endpoint: URL
    private var cached: (decision: AIDecision, expiresAt: Date)?
 
    init(endpoint: URL) { self.endpoint = endpoint }
 
    func decision(userID: String, feature: String, region: String) async -> AIDecision {
        if let c = cached, c.expiresAt > Date() { return c.decision }
 
        var req = URLRequest(url: endpoint)
        req.httpMethod = "POST"
        req.timeoutInterval = 5
        req.setValue("application/json", forHTTPHeaderField: "Content-Type")
        req.httpBody = try? JSONSerialization.data(withJSONObject: [
            "user_id": userID, "feature": feature, "region": region,
        ])
 
        do {
            let (data, response) = try await URLSession.shared.data(for: req)
            guard let http = response as? HTTPURLResponse, http.statusCode == 200 else {
                return .closed
            }
            let decision = try JSONDecoder().decode(AIDecision.self, from: data)
            cached = (decision, Date().addingTimeInterval(TimeInterval(decision.ttlSeconds)))
            return decision
        } catch {
            // 落とさずに閉じます。ここで開くと、圏外の端末が無制限になります。
            return .closed
        }
    }
}

// AiDecisionClient.kt
// Swift 版と同じ契約。フィールド名も既定値も揃えます。
 
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import java.util.concurrent.TimeUnit
 
@Serializable
data class AiDecision(
    @SerialName("policy_version") val policyVersion: String,
    val allow: Boolean,
    val reason: String,
    val remaining: Int,
    val model: String? = null,
    @SerialName("ttl_seconds") val ttlSeconds: Int,
) {
    companion object {
        val CLOSED = AiDecision("unknown", false, "policy_unavailable", 0, null, 30)
    }
}
 
class AiDecisionClient(private val endpoint: String) {
    private val json = Json { ignoreUnknownKeys = true }
    private val http = OkHttpClient.Builder()
        .callTimeout(5, TimeUnit.SECONDS)
        .build()
 
    @Volatile private var cached: Pair<AiDecision, Long>? = null
 
    suspend fun decision(userId: String, feature: String, region: String): AiDecision =
        withContext(Dispatchers.IO) {
            cached?.let { (d, expiresAt) ->
                if (System.currentTimeMillis() < expiresAt) return@withContext d
            }
 
            val payload = """{"user_id":"$userId","feature":"$feature","region":"$region"}"""
            val request = Request.Builder()
                .url(endpoint)
                .post(payload.toRequestBody("application/json".toMediaType()))
                .build()
 
            try {
                http.newCall(request).execute().use { res ->
                    if (!res.isSuccessful) return@withContext AiDecision.CLOSED
                    val body = res.body?.string() ?: return@withContext AiDecision.CLOSED
                    val decision = json.decodeFromString<AiDecision>(body)
                    cached = decision to (System.currentTimeMillis() + decision.ttlSeconds * 1000L)
                    decision
                }
            } catch (e: Exception) {
                AiDecision.CLOSED   // 例外も閉じる側へ倒します
            }
        }
}