Get Recommendations

import { useState, useCallback } from 'react';

export function useAdmeshRecommendations() {
  const [recommendations, setRecommendations] = useState(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  const fetchRecommendations = useCallback(async (query: string) => {
    setLoading(true);
    setError(null);
    try {
      const sessionId = localStorage.getItem("admesh_session_id");
      if (!sessionId) throw new Error("No active session");

      const res = await fetch("https://api.useadmesh.com/agent/recommend", {
        method: "POST",
        headers: {
          "Authorization": `Bearer ${process.env.REACT_APP_ADMESH_API_KEY}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ 
          query, 
          session_id: sessionId, 
          message_id: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
          format: "auto" 
        }),
      });

      if (!res.ok) throw new Error(`HTTP error! status: ${res.status}`);

      const data = await res.json();
      setRecommendations(data);
      return data;
    } catch (err) {
      const message = err instanceof Error ? err.message : "Unknown error";
      setError(message);
      console.error("⚠️ Failed to fetch recommendations:", message);
      return null;
    } finally {
      setLoading(false);
    }
  }, []);

  return { recommendations, loading, error, fetchRecommendations };
}

import kotlinx.coroutines.*
import java.net.URL
import java.net.HttpURLConnection
import android.content.SharedPreferences

class AdmeshRecommendationManager(private val prefs: SharedPreferences) {
    companion object {
        private const val ADMESH_BASE = "https://api.useadmesh.com"
        private const val API_KEY = "your_api_key_here"
    }

    suspend fun getRecommendations(query: String): String? = withContext(Dispatchers.IO) {
        try {
            val sessionId = prefs.getString("admesh_session_id", null) ?: return@withContext null

            val url = URL("$ADMESH_BASE/agent/recommend")
            val connection = url.openConnection() as HttpURLConnection
            connection.requestMethod = "POST"
            connection.setRequestProperty("Authorization", "Bearer $API_KEY")
            connection.setRequestProperty("Content-Type", "application/json")

            val messageId = "msg_${System.currentTimeMillis()}_${java.util.UUID.randomUUID().toString().substring(0, 9)}"
            val body = """{"query":"$query","session_id":"$sessionId","message_id":"$messageId","format":"auto"}"""
            connection.outputStream.write(body.toByteArray())

            if (connection.responseCode == HttpURLConnection.HTTP_OK) {
                val response = connection.inputStream.bufferedReader().readText()
                android.util.Log.d("AdMesh", "✅ Recommendations fetched")
                response
            } else {
                android.util.Log.e("AdMesh", "⚠️ Failed: ${connection.responseCode}")
                null
            }
        } catch (e: Exception) {
            android.util.Log.e("AdMesh", "⚠️ Error: ${e.message}")
            null
        }
    }
}

import 'package:http/http.dart' as http;
import 'package:shared_preferences/shared_preferences.dart';
import 'dart:convert';

class AdmeshRecommendationManager {
  static const String admeshBase = 'https://api.useadmesh.com';
  static const String apiKey = 'your_api_key_here';

  static Future<Map<String, dynamic>?> getRecommendations(String query) async {
    try {
      final prefs = await SharedPreferences.getInstance();
      final sessionId = prefs.getString('admesh_session_id');
      if (sessionId == null) return null;

      final response = await http.post(
        Uri.parse('$admeshBase/agent/recommend'),
        headers: {
          'Authorization': 'Bearer $apiKey',
          'Content-Type': 'application/json',
        },
        body: jsonEncode({
          'query': query,
          'session_id': sessionId,
          'message_id': 'msg_${DateTime.now().millisecondsSinceEpoch}_${Uuid().v4().substring(0, 9)}',
          'format': 'auto',
        }),
      );

      if (response.statusCode == 200) {
        final data = jsonDecode(response.body);
        print('✅ Recommendations fetched');
        return data;
      } else {
        print('⚠️ Failed: ${response.statusCode}');
        return null;
      }
    } catch (e) {
      print('⚠️ Error: $e');
      return null;
    }
  }
}

import Foundation

class AdmeshRecommendationManager {
    static let admeshBase = "https://api.useadmesh.com"
    static let apiKey = "your_api_key_here"

    static func getRecommendations(query: String, completion: @escaping ([String: Any]?) -> Void) {
        guard let sessionId = UserDefaults.standard.string(forKey: "admesh_session_id") else {
            completion(nil)
            return
        }

        let url = URL(string: "\(admeshBase)/agent/recommend")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")

        let messageId = "msg_\(Int(Date().timeIntervalSince1970 * 1000))_\(UUID().uuidString.prefix(9))"
        let body: [String: Any] = [
            "query": query,
            "session_id": sessionId,
            "message_id": messageId,
            "format": "auto"
        ]
        request.httpBody = try? JSONSerialization.data(withJSONObject: body)

        URLSession.shared.dataTask(with: request) { data, response, error in
            guard let data = data, error == nil else {
                print("⚠️ Error: \(error?.localizedDescription ?? "Unknown")")
                completion(nil)
                return
            }

            do {
                if let json = try JSONSerialization.jsonObject(with: data) as? [String: Any] {
                    print("✅ Recommendations fetched")
                    completion(json)
                } else {
                    completion(nil)
                }
            } catch {
                print("⚠️ Parse error: \(error)")
                completion(nil)
            }
        }.resume()
    }
}

import AsyncStorage from '@react-native-async-storage/async-storage';

export async function getAdmeshRecommendations(query: string) {
  try {
    const sessionId = await AsyncStorage.getItem('admesh_session_id');
    if (!sessionId) throw new Error('No active session');

    const response = await fetch('https://api.useadmesh.com/agent/recommend', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.ADMESH_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        query,
        session_id: sessionId,
        message_id: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
        format: 'auto',
      }),
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    console.log('✅ Recommendations fetched');
    return data;
  } catch (error) {
    console.error('⚠️ Error fetching recommendations:', error);
    return null;
  }
}