Gate/AI Integration Guide

Benefits of Using Gate/AI

Secure API key management Critical
Rate limiting and usage monitoring Critical
Unified Authentication API across multiple providers (OpenAI, Anthropic, Google Gemini)
Request analytics and performance metrics

What you need to do

Integration with Gate/AI requires just 3 simple changes to your existing mobile app:

Change your API endpoint

Replace your provider's API URL with your Gate/AI endpoint.
E.g., switch api.openai.com to [your-gate-name].us01.gate-ai.net

Add OAuth authentication with Gate/AI

Get a token from /oauth/token using your client secret. The token lasts for an hour. Store this locally if performing multiple requests.

Add the token as an Authentication header

Set an Authentication Bearer header.

That's it! The same URIs work. Gate/AI will forward your exact request on to the provider and stream the response back to you.

Authentication

Gate/AI uses token-based OAuth authentication. You'll need your client secret from your gate configuration to obtain access tokens.

Authentication Flow

1. Request a token using your client_secret, specifying your client_id and grant_type.
2. Include the token in the Authorization header for API requests
3. Tokens are valid for 60 minutes.
4. Once expired, requst another token.

Using Gate/AI is mostly a drop-in solution. The authentication piece is the only less-simple part. In the code examples, we provide a sample one-shot function getGateAIToken() for returning a token and saving it for later use. You can drop it right into your codebase or use it as a starting point.

Analytics

Gate/AI provides analytics through information collection during the authentication process. When obtaining an auth token, set values for these headers to allow Gate/AI to provide insights into API usage patterns and client behavior.

Supported Headers

The following headers are automatically collected when you request an auth token. You simply need to set them. See the example code (Advanced Token Creation) for an authentication function that uses these headers.

X-Client-Locale: Language and country code. E.g., es-MX or es-ES
X-App-Version: The version of your app in use. E.g., 1.0
X-OS-Version: The version of the OS running. E.g., 15.6
X-User-Status: Whatever you want. It could be the subscription plan in use. Or simply Paid vs Free.
X-Device-Identifier: The unique identifier of the device your app received. Used to unique identify abuse from a specific person, beyond IP Address.
X-Device-Type: The manufacturer of the device.

Privacy & Data Handling

All analytics data is processed in compliance with privacy standards. No personally identifiable information is stored.

Code Examples

Choose your AI provider:

Choose your platform:

iOS (Swift) Code Examples

Before: Direct OpenAI Integration

// Original OpenAI integration
let url = URL(string: "https://api.openai.com/v1/chat/completions")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.addValue("Bearer \(openAIKey)", forHTTPHeaderField: "Authorization")
request.addValue("application/json", forHTTPHeaderField: "Content-Type")

After: Gate/AI Integration

// Step 1: Get Gate/AI token with caching
func getGateAIToken() async throws -> String {
    // Check for cached token first
    let userDefaults = UserDefaults.standard
    if let cachedToken = userDefaults.string(forKey: "gateai_access_token"),
       let expirationDate = userDefaults.object(forKey: "gateai_token_expiration") as? Date,
       Date().addingTimeInterval(10) < expirationDate { // 10 second buffer
        return cachedToken
    }

    // Request new token
    let tokenURL = URL(string: "https://your-gate.gateai.com/oauth/token")!
    var tokenRequest = URLRequest(url: tokenURL)
    tokenRequest.httpMethod = "POST"
    tokenRequest.addValue("application/json", forHTTPHeaderField: "Content-Type")

    let tokenBody = ["client_secret": "your-client-secret"]
    tokenRequest.httpBody = try JSONSerialization.data(withJSONObject: tokenBody)

    let (data, _) = try await URLSession.shared.data(for: tokenRequest)
    let response = try JSONDecoder().decode(TokenResponse.self, from: data)

    // Cache the token and expiration
    let expirationDate = Date().addingTimeInterval(TimeInterval(response.expires_in))
    userDefaults.set(response.access_token, forKey: "gateai_access_token")
    userDefaults.set(expirationDate, forKey: "gateai_token_expiration")

    return response.access_token
}

// Step 2: Use Gate/AI endpoint (same OpenAI-compatible API)
let token = try await getGateAIToken()
let url = URL(string: "https://your-gate.gateai.com/v1/chat/completions")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.addValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
request.addValue("application/json", forHTTPHeaderField: "Content-Type")

Advanced: Enhanced Token Creation

You can include additional metadata when requesting tokens for enhanced monitoring and analytics:

func getGateAITokenWithMetadata() async throws -> String {
    // Check for cached token first
    let userDefaults = UserDefaults.standard
    if let cachedToken = userDefaults.string(forKey: "gateai_access_token"),
       let expirationDate = userDefaults.object(forKey: "gateai_token_expiration") as? Date,
       Date().addingTimeInterval(10) < expirationDate { // 10 second buffer
        return cachedToken
    }

    // Request new token with enhanced metadata
    let tokenURL = URL(string: "https://your-gate.gateai.com/oauth/token")!
    var tokenRequest = URLRequest(url: tokenURL)
    tokenRequest.httpMethod = "POST"
    tokenRequest.addValue("application/json", forHTTPHeaderField: "Content-Type")

    // Get system information dynamically
    let locale = Locale.current.identifier
    let appVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown"
    let osVersion = "\(UIDevice.current.systemName) \(UIDevice.current.systemVersion)"
    let deviceId = UIDevice.current.identifierForVendor?.uuidString ?? "unknown"
    let deviceType = UIDevice.current.name // Device model name (e.g., "iPhone", "iPad")

    // Enhanced metadata headers with system values
    tokenRequest.addValue(locale, forHTTPHeaderField: "x-client-locale")
    tokenRequest.addValue(appVersion, forHTTPHeaderField: "x-app-version")
    tokenRequest.addValue(osVersion, forHTTPHeaderField: "x-os-version")
    tokenRequest.addValue("premium", forHTTPHeaderField: "x-user-status") // Set based on your user logic
    tokenRequest.addValue(deviceId, forHTTPHeaderField: "x-device-identifier")
    tokenRequest.addValue(deviceType, forHTTPHeaderField: "x-device-type")

    let tokenBody = ["client_secret": "your-client-secret"]
    tokenRequest.httpBody = try JSONSerialization.data(withJSONObject: tokenBody)

    let (data, _) = try await URLSession.shared.data(for: tokenRequest)
    let response = try JSONDecoder().decode(TokenResponse.self, from: data)

    // Cache the token and expiration
    let expirationDate = Date().addingTimeInterval(TimeInterval(response.expires_in))
    userDefaults.set(response.access_token, forKey: "gateai_access_token")
    userDefaults.set(expirationDate, forKey: "gateai_token_expiration")

    return response.access_token
}

Before: Direct Anthropic Integration

// Original Anthropic integration
let url = URL(string: "https://api.anthropic.com/v1/messages")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.addValue("Bearer \(anthropicKey)", forHTTPHeaderField: "Authorization")
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.addValue("2023-06-01", forHTTPHeaderField: "anthropic-version")

After: Gate/AI Integration

// Step 1: Get Gate/AI token (same as above)
let token = try await getGateAIToken()

// Step 2: Use Gate/AI endpoint (Anthropic-compatible API)
let url = URL(string: "https://your-gate.gateai.com/v1/messages")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.addValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.addValue("2023-06-01", forHTTPHeaderField: "anthropic-version")

Advanced: Enhanced Token Creation

You can include additional metadata when requesting tokens for enhanced monitoring and analytics:

func getGateAITokenWithMetadata() async throws -> String {
    // Check for cached token first
    let userDefaults = UserDefaults.standard
    if let cachedToken = userDefaults.string(forKey: "gateai_access_token"),
       let expirationDate = userDefaults.object(forKey: "gateai_token_expiration") as? Date,
       Date().addingTimeInterval(10) < expirationDate { // 10 second buffer
        return cachedToken
    }

    // Request new token with enhanced metadata
    let tokenURL = URL(string: "https://your-gate.gateai.com/oauth/token")!
    var tokenRequest = URLRequest(url: tokenURL)
    tokenRequest.httpMethod = "POST"
    tokenRequest.addValue("application/json", forHTTPHeaderField: "Content-Type")

    // Get system information dynamically
    let locale = Locale.current.identifier
    let appVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown"
    let osVersion = "\(UIDevice.current.systemName) \(UIDevice.current.systemVersion)"
    let deviceId = UIDevice.current.identifierForVendor?.uuidString ?? "unknown"
    let deviceType = UIDevice.current.name // Device model name (e.g., "iPhone", "iPad")

    // Enhanced metadata headers with system values
    tokenRequest.addValue(locale, forHTTPHeaderField: "x-client-locale")
    tokenRequest.addValue(appVersion, forHTTPHeaderField: "x-app-version")
    tokenRequest.addValue(osVersion, forHTTPHeaderField: "x-os-version")
    tokenRequest.addValue("premium", forHTTPHeaderField: "x-user-status") // Set based on your user logic
    tokenRequest.addValue(deviceId, forHTTPHeaderField: "x-device-identifier")
    tokenRequest.addValue(deviceType, forHTTPHeaderField: "x-device-type")

    let tokenBody = ["client_secret": "your-client-secret"]
    tokenRequest.httpBody = try JSONSerialization.data(withJSONObject: tokenBody)

    let (data, _) = try await URLSession.shared.data(for: tokenRequest)
    let response = try JSONDecoder().decode(TokenResponse.self, from: data)

    // Cache the token and expiration
    let expirationDate = Date().addingTimeInterval(TimeInterval(response.expires_in))
    userDefaults.set(response.access_token, forKey: "gateai_access_token")
    userDefaults.set(expirationDate, forKey: "gateai_token_expiration")

    return response.access_token
}

Before: Direct Google Gemini Integration

// Original Gemini integration
let url = URL(string: "https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent?key=\(geminiKey)")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.addValue("application/json", forHTTPHeaderField: "Content-Type")

After: Gate/AI Integration

// Step 1: Get Gate/AI token (same as above)
let token = try await getGateAIToken()

// Step 2: Use Gate/AI endpoint (Gemini-compatible API)
let url = URL(string: "https://your-gate.gateai.com/v1/models/gemini-pro:generateContent")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.addValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
request.addValue("application/json", forHTTPHeaderField: "Content-Type")

Advanced: Enhanced Token Creation

You can include additional metadata when requesting tokens for enhanced monitoring and analytics:

func getGateAITokenWithMetadata() async throws -> String {
    // Check for cached token first
    let userDefaults = UserDefaults.standard
    if let cachedToken = userDefaults.string(forKey: "gateai_access_token"),
       let expirationDate = userDefaults.object(forKey: "gateai_token_expiration") as? Date,
       Date().addingTimeInterval(10) < expirationDate { // 10 second buffer
        return cachedToken
    }

    // Request new token with enhanced metadata
    let tokenURL = URL(string: "https://your-gate.gateai.com/oauth/token")!
    var tokenRequest = URLRequest(url: tokenURL)
    tokenRequest.httpMethod = "POST"
    tokenRequest.addValue("application/json", forHTTPHeaderField: "Content-Type")

    // Get system information dynamically
    let locale = Locale.current.identifier
    let appVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown"
    let osVersion = "\(UIDevice.current.systemName) \(UIDevice.current.systemVersion)"
    let deviceId = UIDevice.current.identifierForVendor?.uuidString ?? "unknown"
    let deviceType = UIDevice.current.name // Device model name (e.g., "iPhone", "iPad")

    // Enhanced metadata headers with system values
    tokenRequest.addValue(locale, forHTTPHeaderField: "x-client-locale")
    tokenRequest.addValue(appVersion, forHTTPHeaderField: "x-app-version")
    tokenRequest.addValue(osVersion, forHTTPHeaderField: "x-os-version")
    tokenRequest.addValue("premium", forHTTPHeaderField: "x-user-status") // Set based on your user logic
    tokenRequest.addValue(deviceId, forHTTPHeaderField: "x-device-identifier")
    tokenRequest.addValue(deviceType, forHTTPHeaderField: "x-device-type")

    let tokenBody = ["client_secret": "your-client-secret"]
    tokenRequest.httpBody = try JSONSerialization.data(withJSONObject: tokenBody)

    let (data, _) = try await URLSession.shared.data(for: tokenRequest)
    let response = try JSONDecoder().decode(TokenResponse.self, from: data)

    // Cache the token and expiration
    let expirationDate = Date().addingTimeInterval(TimeInterval(response.expires_in))
    userDefaults.set(response.access_token, forKey: "gateai_access_token")
    userDefaults.set(expirationDate, forKey: "gateai_token_expiration")

    return response.access_token
}

Before: Direct OpenAI Integration

// Original OpenAI integration
val client = OkHttpClient()
val request = Request.Builder()
    .url("https://api.openai.com/v1/chat/completions")
    .addHeader("Authorization", "Bearer $openAIKey")
    .addHeader("Content-Type", "application/json")
    .post(requestBody)
    .build()

After: Gate/AI Integration

// Step 1: Get Gate/AI token with caching
suspend fun getGateAIToken(context: Context): String {
    val sharedPrefs = context.getSharedPreferences("gateai_prefs", Context.MODE_PRIVATE)

    // Check for cached token first
    val cachedToken = sharedPrefs.getString("access_token", null)
    val expirationTime = sharedPrefs.getLong("token_expiration", 0)

    if (cachedToken != null && System.currentTimeMillis() + 10000 < expirationTime) { // 10 second buffer
        return cachedToken
    }

    // Request new token
    val tokenRequest = Request.Builder()
        .url("https://your-gate.gateai.com/oauth/token")
        .addHeader("Content-Type", "application/json")
        .post(
            RequestBody.create(
                "application/json".toMediaType(),
                """{"client_secret": "your-client-secret"}"""
            )
        )
        .build()

    val response = client.newCall(tokenRequest).execute()
    val tokenData = JSONObject(response.body!!.string())
    val accessToken = tokenData.getString("access_token")
    val expiresIn = tokenData.getInt("expires_in")

    // Cache the token and expiration
    val expirationTimeMs = System.currentTimeMillis() + (expiresIn * 1000)
    sharedPrefs.edit()
        .putString("access_token", accessToken)
        .putLong("token_expiration", expirationTimeMs)
        .apply()

    return accessToken
}

// Step 2: Use Gate/AI endpoint (same OpenAI-compatible API)
val token = getGateAIToken(context)
val request = Request.Builder()
    .url("https://your-gate.gateai.com/v1/chat/completions")
    .addHeader("Authorization", "Bearer $token")
    .addHeader("Content-Type", "application/json")
    .post(requestBody)
    .build()

Advanced: Enhanced Token Creation

You can include additional metadata when requesting tokens for enhanced monitoring and analytics:

suspend fun getGateAITokenWithMetadata(context: Context): String {
    val sharedPrefs = context.getSharedPreferences("gateai_prefs", Context.MODE_PRIVATE)

    // Check for cached token first
    val cachedToken = sharedPrefs.getString("access_token", null)
    val expirationTime = sharedPrefs.getLong("token_expiration", 0)

    if (cachedToken != null && System.currentTimeMillis() + 10000 < expirationTime) { // 10 second buffer
        return cachedToken
    }

    // Get system information dynamically
    val locale = Locale.getDefault().toString()
    val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
    val appVersion = packageInfo.versionName ?: "unknown"
    val osVersion = "Android ${Build.VERSION.RELEASE}"
    val deviceId = Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID)
    val deviceType = "${Build.MANUFACTURER} ${Build.MODEL}" // Device model name (e.g., "Samsung SM-G991B")

    // Request new token with enhanced metadata
    val tokenRequest = Request.Builder()
        .url("https://your-gate.gateai.com/oauth/token")
        .addHeader("Content-Type", "application/json")
        // Enhanced metadata headers with system values
        .addHeader("x-client-locale", locale)
        .addHeader("x-app-version", appVersion)
        .addHeader("x-os-version", osVersion)
        .addHeader("x-user-status", "premium") // Set based on your user logic
        .addHeader("x-device-identifier", deviceId)
        .addHeader("x-device-type", deviceType)
        .post(
            RequestBody.create(
                "application/json".toMediaType(),
                """{"client_secret": "your-client-secret"}"""
            )
        )
        .build()

    val response = client.newCall(tokenRequest).execute()
    val tokenData = JSONObject(response.body!!.string())
    val accessToken = tokenData.getString("access_token")
    val expiresIn = tokenData.getInt("expires_in")

    // Cache the token and expiration
    val expirationTimeMs = System.currentTimeMillis() + (expiresIn * 1000)
    sharedPrefs.edit()
        .putString("access_token", accessToken)
        .putLong("token_expiration", expirationTimeMs)
        .apply()

    return accessToken
}

Before: Direct Anthropic Integration

// Original Anthropic integration
val client = OkHttpClient()
val request = Request.Builder()
    .url("https://api.anthropic.com/v1/messages")
    .addHeader("Authorization", "Bearer $anthropicKey")
    .addHeader("Content-Type", "application/json")
    .addHeader("anthropic-version", "2023-06-01")
    .post(requestBody)
    .build()

After: Gate/AI Integration

// Step 1: Get Gate/AI token (same as above)
val token = getGateAIToken(context)

// Step 2: Use Gate/AI endpoint (Anthropic-compatible API)
val request = Request.Builder()
    .url("https://your-gate.gateai.com/v1/messages")
    .addHeader("Authorization", "Bearer $token")
    .addHeader("Content-Type", "application/json")
    .addHeader("anthropic-version", "2023-06-01")
    .post(requestBody)
    .build()

Advanced: Enhanced Token Creation

You can include additional metadata when requesting tokens for enhanced monitoring and analytics:

suspend fun getGateAITokenWithMetadata(context: Context): String {
    val sharedPrefs = context.getSharedPreferences("gateai_prefs", Context.MODE_PRIVATE)

    // Check for cached token first
    val cachedToken = sharedPrefs.getString("access_token", null)
    val expirationTime = sharedPrefs.getLong("token_expiration", 0)

    if (cachedToken != null && System.currentTimeMillis() + 10000 < expirationTime) { // 10 second buffer
        return cachedToken
    }

    // Get system information dynamically
    val locale = Locale.getDefault().toString()
    val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
    val appVersion = packageInfo.versionName ?: "unknown"
    val osVersion = "Android ${Build.VERSION.RELEASE}"
    val deviceId = Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID)
    val deviceType = "${Build.MANUFACTURER} ${Build.MODEL}" // Device model name (e.g., "Samsung SM-G991B")

    // Request new token with enhanced metadata
    val tokenRequest = Request.Builder()
        .url("https://your-gate.gateai.com/oauth/token")
        .addHeader("Content-Type", "application/json")
        // Enhanced metadata headers with system values
        .addHeader("x-client-locale", locale)
        .addHeader("x-app-version", appVersion)
        .addHeader("x-os-version", osVersion)
        .addHeader("x-user-status", "premium") // Set based on your user logic
        .addHeader("x-device-identifier", deviceId)
        .addHeader("x-device-type", deviceType)
        .post(
            RequestBody.create(
                "application/json".toMediaType(),
                """{"client_secret": "your-client-secret"}"""
            )
        )
        .build()

    val response = client.newCall(tokenRequest).execute()
    val tokenData = JSONObject(response.body!!.string())
    val accessToken = tokenData.getString("access_token")
    val expiresIn = tokenData.getInt("expires_in")

    // Cache the token and expiration
    val expirationTimeMs = System.currentTimeMillis() + (expiresIn * 1000)
    sharedPrefs.edit()
        .putString("access_token", accessToken)
        .putLong("token_expiration", expirationTimeMs)
        .apply()

    return accessToken
}

Before: Direct Google Gemini Integration

// Original Gemini integration
val client = OkHttpClient()
val request = Request.Builder()
    .url("https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent?key=$geminiKey")
    .addHeader("Content-Type", "application/json")
    .post(requestBody)
    .build()

After: Gate/AI Integration

// Step 1: Get Gate/AI token (same as above)
val token = getGateAIToken(context)

// Step 2: Use Gate/AI endpoint (Gemini-compatible API)
val request = Request.Builder()
    .url("https://your-gate.gateai.com/v1/models/gemini-pro:generateContent")
    .addHeader("Authorization", "Bearer $token")
    .addHeader("Content-Type", "application/json")
    .post(requestBody)
    .build()

Advanced: Enhanced Token Creation

You can include additional metadata when requesting tokens for enhanced monitoring and analytics:

suspend fun getGateAITokenWithMetadata(context: Context): String {
    val sharedPrefs = context.getSharedPreferences("gateai_prefs", Context.MODE_PRIVATE)

    // Check for cached token first
    val cachedToken = sharedPrefs.getString("access_token", null)
    val expirationTime = sharedPrefs.getLong("token_expiration", 0)

    if (cachedToken != null && System.currentTimeMillis() + 10000 < expirationTime) { // 10 second buffer
        return cachedToken
    }

    // Get system information dynamically
    val locale = Locale.getDefault().toString()
    val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
    val appVersion = packageInfo.versionName ?: "unknown"
    val osVersion = "Android ${Build.VERSION.RELEASE}"
    val deviceId = Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID)
    val deviceType = "${Build.MANUFACTURER} ${Build.MODEL}" // Device model name (e.g., "Samsung SM-G991B")

    // Request new token with enhanced metadata
    val tokenRequest = Request.Builder()
        .url("https://your-gate.gateai.com/oauth/token")
        .addHeader("Content-Type", "application/json")
        // Enhanced metadata headers with system values
        .addHeader("x-client-locale", locale)
        .addHeader("x-app-version", appVersion)
        .addHeader("x-os-version", osVersion)
        .addHeader("x-user-status", "premium") // Set based on your user logic
        .addHeader("x-device-identifier", deviceId)
        .addHeader("x-device-type", deviceType)
        .post(
            RequestBody.create(
                "application/json".toMediaType(),
                """{"client_secret": "your-client-secret"}"""
            )
        )
        .build()

    val response = client.newCall(tokenRequest).execute()
    val tokenData = JSONObject(response.body!!.string())
    val accessToken = tokenData.getString("access_token")
    val expiresIn = tokenData.getInt("expires_in")

    // Cache the token and expiration
    val expirationTimeMs = System.currentTimeMillis() + (expiresIn * 1000)
    sharedPrefs.edit()
        .putString("access_token", accessToken)
        .putLong("token_expiration", expirationTimeMs)
        .apply()

    return accessToken
}

Before: Direct OpenAI Integration

// Original OpenAI integration
const response = await fetch('https://api.openai.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${OPENAI_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(payload)
});

After: Gate/AI Integration

// Step 1: Get Gate/AI token with caching
import AsyncStorage from '@react-native-async-storage/async-storage';

const getGateAIToken = async () => {
  try {
    // Check for cached token first
    const cachedToken = await AsyncStorage.getItem('gateai_access_token');
    const expirationTime = await AsyncStorage.getItem('gateai_token_expiration');

    if (cachedToken && expirationTime && Date.now() + 10000 < parseInt(expirationTime)) { // 10 second buffer
      return cachedToken;
    }

    // Request new token
    const tokenResponse = await fetch('https://your-gate.gateai.com/oauth/token', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        client_secret: 'your-client-secret'
      })
    });

    const tokenData = await tokenResponse.json();
    const accessToken = tokenData.access_token;
    const expiresIn = tokenData.expires_in;

    // Cache the token and expiration
    const expirationTimeMs = Date.now() + (expiresIn * 1000);
    await AsyncStorage.setItem('gateai_access_token', accessToken);
    await AsyncStorage.setItem('gateai_token_expiration', expirationTimeMs.toString());

    return accessToken;
  } catch (error) {
    console.error('Error getting GateAI token:', error);
    throw error;
  }
};

// Step 2: Use Gate/AI endpoint (same OpenAI-compatible API)
const token = await getGateAIToken();
const response = await fetch('https://your-gate.gateai.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(payload)
});

Advanced: Enhanced Token Creation

You can include additional metadata when requesting tokens for enhanced monitoring and analytics:

import { Platform } from 'react-native';
import DeviceInfo from 'react-native-device-info';
import { getLocales } from 'react-native-localize';
import AsyncStorage from '@react-native-async-storage/async-storage';

const getGateAITokenWithMetadata = async () => {
  try {
    // Check for cached token first
    const cachedToken = await AsyncStorage.getItem('gateai_access_token');
    const expirationTime = await AsyncStorage.getItem('gateai_token_expiration');

    if (cachedToken && expirationTime && Date.now() + 10000 < parseInt(expirationTime)) { // 10 second buffer
      return cachedToken;
    }

    // Get system information dynamically
    const locale = getLocales()[0]?.languageTag || 'en-US';
    const appVersion = DeviceInfo.getVersion();
    const osVersion = `${Platform.OS} ${DeviceInfo.getSystemVersion()}`;
    const deviceId = await DeviceInfo.getUniqueId();
    const deviceType = await DeviceInfo.getModel(); // Device model name (e.g., "iPhone13,2", "SM-G991B")

    // Request new token with enhanced metadata
    const tokenResponse = await fetch('https://your-gate.gateai.com/oauth/token', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        // Enhanced metadata headers with system values
        'x-client-locale': locale,
        'x-app-version': appVersion,
        'x-os-version': osVersion,
        'x-user-status': 'premium', // Set based on your user logic
        'x-device-identifier': deviceId,
        'x-device-type': deviceType
      },
      body: JSON.stringify({
        client_secret: 'your-client-secret'
      })
    });

    const tokenData = await tokenResponse.json();
    const accessToken = tokenData.access_token;
    const expiresIn = tokenData.expires_in;

    // Cache the token and expiration
    const expirationTimeMs = Date.now() + (expiresIn * 1000);
    await AsyncStorage.setItem('gateai_access_token', accessToken);
    await AsyncStorage.setItem('gateai_token_expiration', expirationTimeMs.toString());

    return accessToken;
  } catch (error) {
    console.error('Error getting GateAI token with metadata:', error);
    throw error;
  }
};

Before: Direct Anthropic Integration

// Original Anthropic integration
const response = await fetch('https://api.anthropic.com/v1/messages', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${ANTHROPIC_API_KEY}`,
    'Content-Type': 'application/json',
    'anthropic-version': '2023-06-01'
  },
  body: JSON.stringify(payload)
});

After: Gate/AI Integration

// Step 1: Get Gate/AI token (same as above)
const token = await getGateAIToken();

// Step 2: Use Gate/AI endpoint (Anthropic-compatible API)
const response = await fetch('https://your-gate.gateai.com/v1/messages', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json',
    'anthropic-version': '2023-06-01'
  },
  body: JSON.stringify(payload)
});

Advanced: Enhanced Token Creation

You can include additional metadata when requesting tokens for enhanced monitoring and analytics:

import { Platform } from 'react-native';
import DeviceInfo from 'react-native-device-info';
import { getLocales } from 'react-native-localize';
import AsyncStorage from '@react-native-async-storage/async-storage';

const getGateAITokenWithMetadata = async () => {
  try {
    // Check for cached token first
    const cachedToken = await AsyncStorage.getItem('gateai_access_token');
    const expirationTime = await AsyncStorage.getItem('gateai_token_expiration');

    if (cachedToken && expirationTime && Date.now() + 10000 < parseInt(expirationTime)) { // 10 second buffer
      return cachedToken;
    }

    // Get system information dynamically
    const locale = getLocales()[0]?.languageTag || 'en-US';
    const appVersion = DeviceInfo.getVersion();
    const osVersion = `${Platform.OS} ${DeviceInfo.getSystemVersion()}`;
    const deviceId = await DeviceInfo.getUniqueId();
    const deviceType = await DeviceInfo.getModel(); // Device model name (e.g., "iPhone13,2", "SM-G991B")

    // Request new token with enhanced metadata
    const tokenResponse = await fetch('https://your-gate.gateai.com/oauth/token', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        // Enhanced metadata headers with system values
        'x-client-locale': locale,
        'x-app-version': appVersion,
        'x-os-version': osVersion,
        'x-user-status': 'premium', // Set based on your user logic
        'x-device-identifier': deviceId,
        'x-device-type': deviceType
      },
      body: JSON.stringify({
        client_secret: 'your-client-secret'
      })
    });

    const tokenData = await tokenResponse.json();
    const accessToken = tokenData.access_token;
    const expiresIn = tokenData.expires_in;

    // Cache the token and expiration
    const expirationTimeMs = Date.now() + (expiresIn * 1000);
    await AsyncStorage.setItem('gateai_access_token', accessToken);
    await AsyncStorage.setItem('gateai_token_expiration', expirationTimeMs.toString());

    return accessToken;
  } catch (error) {
    console.error('Error getting GateAI token with metadata:', error);
    throw error;
  }
};

Before: Direct Google Gemini Integration

// Original Gemini integration
const response = await fetch(`https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent?key=${GEMINI_API_KEY}`, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(payload)
});

After: Gate/AI Integration

// Step 1: Get Gate/AI token (same as above)
const token = await getGateAIToken();

// Step 2: Use Gate/AI endpoint (Gemini-compatible API)
const response = await fetch('https://your-gate.gateai.com/v1/models/gemini-pro:generateContent', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(payload)
});

Advanced: Enhanced Token Creation

You can include additional metadata when requesting tokens for enhanced monitoring and analytics:

import { Platform } from 'react-native';
import DeviceInfo from 'react-native-device-info';
import { getLocales } from 'react-native-localize';
import AsyncStorage from '@react-native-async-storage/async-storage';

const getGateAITokenWithMetadata = async () => {
  try {
    // Check for cached token first
    const cachedToken = await AsyncStorage.getItem('gateai_access_token');
    const expirationTime = await AsyncStorage.getItem('gateai_token_expiration');

    if (cachedToken && expirationTime && Date.now() + 10000 < parseInt(expirationTime)) { // 10 second buffer
      return cachedToken;
    }

    // Get system information dynamically
    const locale = getLocales()[0]?.languageTag || 'en-US';
    const appVersion = DeviceInfo.getVersion();
    const osVersion = `${Platform.OS} ${DeviceInfo.getSystemVersion()}`;
    const deviceId = await DeviceInfo.getUniqueId();
    const deviceType = await DeviceInfo.getModel(); // Device model name (e.g., "iPhone13,2", "SM-G991B")

    // Request new token with enhanced metadata
    const tokenResponse = await fetch('https://your-gate.gateai.com/oauth/token', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        // Enhanced metadata headers with system values
        'x-client-locale': locale,
        'x-app-version': appVersion,
        'x-os-version': osVersion,
        'x-user-status': 'premium', // Set based on your user logic
        'x-device-identifier': deviceId,
        'x-device-type': deviceType
      },
      body: JSON.stringify({
        client_secret: 'your-client-secret'
      })
    });

    const tokenData = await tokenResponse.json();
    const accessToken = tokenData.access_token;
    const expiresIn = tokenData.expires_in;

    // Cache the token and expiration
    const expirationTimeMs = Date.now() + (expiresIn * 1000);
    await AsyncStorage.setItem('gateai_access_token', accessToken);
    await AsyncStorage.setItem('gateai_token_expiration', expirationTimeMs.toString());

    return accessToken;
  } catch (error) {
    console.error('Error getting GateAI token with metadata:', error);
    throw error;
  }
};