Where the AI decision lives once Rork splits your app into two native codebases

// worker/src/ai-decision.ts
// The single place two native apps go to get the SAME answer.
// Clients do not decide. They receive and obey.
 
export interface Env {
  AI_POLICY: KVNamespace;            // the policy itself, versioned
  USAGE: DurableObjectNamespace;     // the usage tally
}
 
type Reason =
  | 'ok'
  | 'quota_exceeded'
  | 'region_blocked'
  | 'feature_disabled'
  | 'policy_unavailable';
 
interface Decision {
  policy_version: string;  // must appear in both clients' logs
  allow: boolean;
  reason: Reason;
  remaining: number;       // calls left today
  model: string | null;    // null when we are stopping
  ttl_seconds: number;     // how long a client may wait before asking again
}
 
// The default used when the policy cannot be read.
// Failing to allow: false is the whole point — flip it to true and
// every device gets unlimited calls for exactly as long as you are down.
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; // a KV read failure also falls to the closed side
    }
    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,
      );
    }
 
    // Count usage in one place, in a Durable Object.
    // Per-device counters roll back on reinstall and double on device change.
    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
// Holds no policy. Receives an envelope and obeys it.
 
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"
    }
 
    // Used when the call fails. Must mean exactly what CLOSED means on the server.
    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 {
            // Close, do not crash. Opening here makes every offline device unlimited.
            return .closed
        }
    }
}

// AiDecisionClient.kt
// Same contract as the Swift version. Field names and defaults must match.
 
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   // exceptions fall to the closed side too
            }
        }
}