Authentication

using System.Net.Http;
using System.Text;
using System.Text.Json;
 
public class LoreMindService
{
    private readonly HttpClient _http;
    private readonly string _apiKey;
 
    public LoreMindService(string apiKey)
    {
        _apiKey = apiKey;
        _http = new HttpClient
        {
            BaseAddress = new Uri("https://loremind.peekgames.dev/api/loremind/v1/")
        };
        _http.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
    }
 
    public async Task<NPCResponse> GetNPCResponse(
        string playerId,
        string entityMindId,
        string playerMessage,
        GameContext gameContext)
    {
        var request = new
        {
            text = playerMessage,
            entityMindId = entityMindId,
            playerId = playerId,  // For per-player rate limiting and memory
            memory = new { retrieve = true },
            context = BuildRuntimeContext(gameContext)
        };
 
        var json = JsonSerializer.Serialize(request);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
 
        var response = await _http.PostAsync("npc/interact", content);
 
        if (!response.IsSuccessStatusCode)
        {
            var error = await response.Content.ReadAsStringAsync();
            throw new LoreMindException($"API error: {error}");
        }
 
        return await JsonSerializer.DeserializeAsync<NPCResponse>(
            await response.Content.ReadAsStreamAsync());
    }
 
    private object BuildRuntimeContext(GameContext ctx)
    {
        // Build context from your game server's knowledge of the world
        return new
        {
            location = ctx.CurrentLocation?.Name,
            locationDetails = ctx.CurrentLocation?.Description,
            timeOfDay = ctx.WorldTime.ToTimeOfDay(),
            weather = ctx.Weather.ToString().ToLower(),
            nearbyCharacters = ctx.NearbyNPCs.Select(n => n.DisplayName).ToArray(),
            playerAppearance = ctx.Player.GetAppearanceDescription(),
            playerReputation = ctx.Player.GetReputationWith(ctx.CurrentNPC.Faction),
            situation = ctx.CurrentInteractionType,
            recentEvents = ctx.RecentWorldEvents.Take(5).ToArray()
        };
    }
}

// ASP.NET Core example
[ApiController]
[Route("api/npc")]
public class NPCController : ControllerBase
{
    private readonly LoreMindService _loreMind;
    private readonly IPlayerService _players;
    private readonly IGameStateService _gameState;
 
    [HttpPost("interact")]
    [Authorize]  // Your auth - Steam, Epic, custom JWT, etc.
    public async Task<IActionResult> Interact([FromBody] NPCInteractRequest request)
    {
        // Get authenticated player from your auth system
        var playerId = User.GetPlayerId();
        var player = await _players.GetPlayer(playerId);
 
        // Your rate limiting
        if (!await _rateLimiter.TryAcquire(playerId, "npc_interact"))
        {
            return StatusCode(429, "Too many requests");
        }
 
        // Build context from your game state
        var gameContext = await _gameState.GetContextForPlayer(playerId);
 
        // Call LoreMind
        var response = await _loreMind.GetNPCResponse(
            playerId: playerId,
            entityMindId: request.EntityMindId,
            playerMessage: request.Message,
            gameContext: gameContext
        );
 
        // Log for your analytics
        _analytics.TrackNPCInteraction(playerId, request.EntityMindId, response.Metadata);
 
        return Ok(new
        {
            response = response.Response,
            character = response.Character
        });
    }
}

using UnityEngine;
using UnityEngine.Networking;
 
public class NPCClient : MonoBehaviour
{
    [SerializeField] private string gameServerUrl = "https://api.yourgame.com";
 
    public async Task<string> TalkToNPC(string entityMindId, string message)
    {
        var request = new { entityMindId, message };
        var json = JsonUtility.ToJson(request);
 
        using var webRequest = new UnityWebRequest($"{gameServerUrl}/api/npc/interact", "POST");
        webRequest.uploadHandler = new UploadHandlerRaw(System.Text.Encoding.UTF8.GetBytes(json));
        webRequest.downloadHandler = new DownloadHandlerBuffer();
        webRequest.SetRequestHeader("Content-Type", "application/json");
        webRequest.SetRequestHeader("Authorization", $"Bearer {GetPlayerToken()}");
 
        await webRequest.SendWebRequest();
 
        if (webRequest.result != UnityWebRequest.Result.Success)
        {
            Debug.LogError($"NPC request failed: {webRequest.error}");
            return null;
        }
 
        var response = JsonUtility.FromJson<NPCResponse>(webRequest.downloadHandler.text);
        return response.response;
    }
 
    private string GetPlayerToken()
    {
        // Return auth token from your player authentication system
        return PlayerAuth.CurrentToken;
    }
}

// Example: Custom rate limiting in your server
if (player.NPCInteractionsToday > dailyLimit)
{
    return TooManyRequests("Daily NPC limit reached");
}
 
if (player.LastNPCInteraction > DateTime.UtcNow.AddSeconds(-cooldownSeconds))
{
    return TooManyRequests("Please wait before talking again");
}

using Peek.LoreMind;
 
// SDK handles authentication automatically
var npc = GetComponent<LoreMindNPC>();
var response = await npc.RespondAsync("Hello!");