AI.cs

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.DurableTask;
using Microsoft.Extensions.Logging;
using OpenAI_API;

namespace CopilotAzureChatGPT5o
{
    public static class AIAgentOrchestrator
    {
        [FunctionName("AIAgentOrchestrator")]
        public static async Task Run(
            [OrchestrationTrigger] IDurableOrchestrationContext context,
            ILogger log)
        {
            // Retrieve short-term memory (STM) or initialize
            var shortTermMemory = context.GetInput<List<string>>() ?? new List<string>();

            // Wait for a new novel input via an external event
            string novelInput = await context.WaitForExternalEvent<string>("NovelInput");
            shortTermMemory.Add(novelInput);
            log.LogInformation($"[Orchestrator] Received novel input: {novelInput}");

            // Process the input using OpenAI via an activity function
            string openAiResponse = await context.CallActivityAsync<string>("ProcessNovelInputActivity", novelInput);
            log.LogInformation($"[Orchestrator] OpenAI response: {openAiResponse}");

            // Check if STM needs to be consolidated into LTM
            if (shortTermMemory.Count >= 5 || context.CurrentUtcDateTime.Subtract(context.StartTime).TotalMinutes >= 10)
            {
                await context.CallActivityAsync("ConsolidateMemory", shortTermMemory);
                log.LogInformation("[Orchestrator] STM consolidated into LTM.");
                shortTermMemory.Clear();
            }

            // Prevent excessive history buildup by using ContinueAsNew
            context.ContinueAsNew(shortTermMemory);
        }
    }

    public static class ProcessNovelInputActivity
    {
        [FunctionName("ProcessNovelInputActivity")]
        public static async Task<string> Run(
            [ActivityTrigger] string novelInput,
            ILogger log)
        {
            string apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
            if (string.IsNullOrEmpty(apiKey))
            {
                log.LogError("OpenAI API key is not set in environment variables.");
                return "Error: No API key";
            }

            var openAiClient = new OpenAIAPI(apiKey);
            var completionRequest = new OpenAI_API.Completions.CompletionRequest
            {
                Prompt = $"Process this input and provide insights: {novelInput}",
                MaxTokens = 100,
                Temperature = 0.7
            };

            try
            {
                var result = await openAiClient.Completions.CreateCompletionAsync(completionRequest);
                string response = result.Completions?[0].Text.Trim() ?? "No response";
                log.LogInformation($"[ProcessNovelInputActivity] Processed input: {novelInput} | Response: {response}");
                return response;
            }
            catch (Exception ex)
            {
                log.LogError($"[ProcessNovelInputActivity] OpenAI API error: {ex.Message}");
                return "Error processing input";
            }
        }
    }

    public static class ConsolidateMemory
    {
        [FunctionName("ConsolidateMemory")]
        public static async Task Run(
            [ActivityTrigger] List<string> memoryBatch,
            ILogger log)
        {
            log.LogInformation("[ConsolidateMemory] Consolidating STM into LTM.");
            foreach (var item in memoryBatch)
            {
                log.LogInformation($" - {item}");
            }
            await Task.Delay(500); // Simulate database write
        }
    }

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.DurableTask;
using Microsoft.Extensions.Logging;
using Azure.Data.Tables;
using System.Linq;
using OpenAI_API;

namespace CopilotAzureChatGPT5o
{
    public static class SelfLearningAI
    {
        private const string TableName = "AIMemoryTable";
        private static TableClient _tableClient;

        [FunctionName("InitializeMemory")]
        public static async Task InitializeMemory([TimerTrigger("0 */30 * * * *")] TimerInfo myTimer, ILogger log)
        {
            var connectionString = Environment.GetEnvironmentVariable("AZURE_STORAGE_CONNECTION_STRING");
            _tableClient = new TableClient(connectionString, TableName);
            await _tableClient.CreateIfNotExistsAsync();
            log.LogInformation("[Memory] AI Memory Initialized.");
        }

        [FunctionName("StoreMemory")]
        public static async Task StoreMemory([ActivityTrigger] MemoryEntry memory, ILogger log)
        {
            await _tableClient.AddEntityAsync(memory);
            log.LogInformation($"[Memory] Stored: {memory.Input} → {memory.Response}");
        }

        [FunctionName("RetrieveMemory")]
        public static async Task<List<MemoryEntry>> RetrieveMemory([ActivityTrigger] string query, ILogger log)
        {
            var results = _tableClient.QueryAsync<MemoryEntry>(m => m.Input.Contains(query));
            List<MemoryEntry> memoryEntries = new();
            await foreach (var entry in results) memoryEntries.Add(entry);
            log.LogInformation($"[Memory] Retrieved {memoryEntries.Count} relevant memories.");
            return memoryEntries;
        }

        [FunctionName("ProcessUserQuery")]
        public static async Task<string> ProcessUserQuery([OrchestrationTrigger] IDurableOrchestrationContext context, ILogger log)
        {
            string userInput = context.GetInput<string>();
            log.LogInformation($"[AI] Processing input: {userInput}");

            // Retrieve past similar queries from memory
            var previousResponses = await context.CallActivityAsync<List<MemoryEntry>>("RetrieveMemory", userInput);
            if (previousResponses.Any())
            {
                var bestMatch = previousResponses.OrderByDescending(m => m.Timestamp).First();
                log.LogInformation($"[Memory] Found past response: {bestMatch.Response}");
                return bestMatch.Response;
            }

            // No memory match, call OpenAI API
            string aiResponse = await context.CallActivityAsync<string>("ProcessWithOpenAI", userInput);
            log.LogInformation($"[AI] OpenAI Response: {aiResponse}");

            // Store new knowledge
            var newMemory = new MemoryEntry { PartitionKey = "AI_Memory", RowKey = Guid.NewGuid().ToString(), Input = userInput, Response = aiResponse };
            await context.CallActivityAsync("StoreMemory", newMemory);

            return aiResponse;
        }

        [FunctionName("ProcessWithOpenAI")]
        public static async Task<string> ProcessWithOpenAI([ActivityTrigger] string input, ILogger log)
        {
            string apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
            if (string.IsNullOrEmpty(apiKey))
            {
                log.LogError("OpenAI API key is missing.");
                return "Error: No API key.";
            }

            var openAiClient = new OpenAIAPI(apiKey);
            var completionRequest = new OpenAI_API.Completions.CompletionRequest
            {
                Prompt = $"Learn from the following input and respond: {input}",
                MaxTokens = 100,
                Temperature = 0.7
            };

            try
            {
                var result = await openAiClient.Completions.CreateCompletionAsync(completionRequest);
                string response = result.Completions?[0].Text.Trim() ?? "No response";
                log.LogInformation($"[AI] Generated response: {response}");
                return response;
            }
            catch (Exception ex)
            {
                log.LogError($"[AI] OpenAI API error: {ex.Message}");
                return "Error processing input.";
            }
        }
    }

    public class MemoryEntry : ITableEntity
    {
        public string PartitionKey { get; set; }
        public string RowKey { get; set; }
        public string Input { get; set; }
        public string Response { get; set; }
        public DateTimeOffset Timestamp { get; set; }
        public string ETag { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Azure.AI.TextAnalytics;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.DurableTask;
using Microsoft.Extensions.Logging;

namespace CopilotAzureChatGPT5o
{
    public static class EmotionMemory
    {
        private static readonly string _textAnalyticsKey = Environment.GetEnvironmentVariable("TEXT_ANALYTICS_KEY");
        private static readonly string _textAnalyticsEndpoint = Environment.GetEnvironmentVariable("TEXT_ANALYTICS_ENDPOINT");

        private static readonly TextAnalyticsClient _client = new(
            new Uri(_textAnalyticsEndpoint), 
            new AzureKeyCredential(_textAnalyticsKey)
        );

        [FunctionName("AnalyzeSentiment")]
        public static async Task<string> AnalyzeSentiment([ActivityTrigger] string message, ILogger log)
        {
            DocumentSentiment sentiment = await _client.AnalyzeSentimentAsync(message);
            string emotion = sentiment.Sentiment.ToString();
            log.LogInformation($"[Sentiment] Message: '{message}' → Emotion: {emotion}");
            return emotion;
        }

        [FunctionName("StoreEmotionMemory")]
        public static async Task StoreEmotionMemory([ActivityTrigger] MemoryEntry memory, ILogger log)
        {
            memory.Sentiment = await AnalyzeSentiment(memory.Input, log);
            await GraphMemory.StoreGraphMemory(memory, log);
            log.LogInformation($"[Memory] Stored sentiment-based memory: {memory.Input} → {memory.Response} [Sentiment: {memory.Sentiment}]");
        }
    }
}

using System;
using System.Threading.Tasks;
using Azure.AI.TextAnalytics;
using Azure.AI.Speech;
using Azure.AI.Speech.Audio;
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;

namespace CopilotAzureChatGPT5o
{
    public static class VoiceAI
    {
        private static readonly string _speechKey = Environment.GetEnvironmentVariable("SPEECH_KEY");
        private static readonly string _speechRegion = Environment.GetEnvironmentVariable("SPEECH_REGION");

        private static readonly SpeechConfig _speechConfig = SpeechConfig.FromSubscription(_speechKey, _speechRegion);

        [FunctionName("SpeechToText")]
        public static async Task<string> SpeechToText([ActivityTrigger] byte[] audioData, ILogger log)
        {
            using var audioInput = AudioDataStream.FromResult(audioData);
            using var recognizer = new SpeechRecognizer(_speechConfig, AudioConfig.FromStreamInput(audioInput));

            var result = await recognizer.RecognizeOnceAsync();
            log.LogInformation($"[STT] Recognized: {result.Text}");
            return result.Text;
        }

        [FunctionName("TextToSpeech")]
        public static async Task<byte[]> TextToSpeech([ActivityTrigger] string text, ILogger log)
        {
            using var synthesizer = new SpeechSynthesizer(_speechConfig, null);
            var result = await synthesizer.SpeakTextAsync(text);
            log.LogInformation($"[TTS] Synthesized Speech for: {text}");
            return result.AudioData;
        }
    }
}

public static class PersonalizedAI
{
    [FunctionName("FineTunedResponse")]
    public static async Task<string> FineTunedResponse([ActivityTrigger] string input, ILogger log)
    {
        string apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
        string fineTunedModel = Environment.GetEnvironmentVariable("OPENAI_FINE_TUNED_MODEL");

        var openAiClient = new OpenAIAPI(apiKey);
        var completionRequest = new OpenAI_API.Completions.CompletionRequest
        {
            Model = fineTunedModel,
            Prompt = input,
            MaxTokens = 100,
            Temperature = 0.7
        };

        try
        {
            var result = await openAiClient.Completions.CreateCompletionAsync(completionRequest);
            return result.Completions?[0].Text.Trim() ?? "No response";
        }
        catch (Exception ex)
        {
            log.LogError($"[Fine-Tuned AI] Error: {ex.Message}");
            return "Error processing input.";
        }
    }
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
using Neo4j.Driver;

namespace CopilotAzureChatGPT5o
{
    public static class GraphMemory
    {
        private static readonly string Neo4jUri = Environment.GetEnvironmentVariable("NEO4J_URI");
        private static readonly string Neo4jUser = Environment.GetEnvironmentVariable("NEO4J_USER");
        private static readonly string Neo4jPassword = Environment.GetEnvironmentVariable("NEO4J_PASSWORD");
        
        private static IDriver _driver = GraphDatabase.Driver(Neo4jUri, AuthTokens.Basic(Neo4jUser, Neo4jPassword));

        [FunctionName("StoreGraphMemory")]
        public static async Task StoreGraphMemory([ActivityTrigger] MemoryEntry memory, ILogger log)
        {
            await using var session = _driver.AsyncSession();
            await session.WriteTransactionAsync(async tx =>
            {
                await tx.RunAsync("MERGE (m:Memory {input: $input}) SET m.response = $response",
                    new { input = memory.Input, response = memory.Response });
            });
            log.LogInformation($"[GraphMemory] Stored knowledge in Neo4j: {memory.Input} → {memory.Response}");
        }

        [FunctionName("RetrieveGraphMemory")]
        public static async Task<string> RetrieveGraphMemory([ActivityTrigger] string query, ILogger log)
        {
            await using var session = _driver.AsyncSession();
            var result = await session.ReadTransactionAsync(async tx =>
            {
                var reader = await tx.RunAsync("MATCH (m:Memory) WHERE m.input CONTAINS $query RETURN m.response LIMIT 1",
                    new { query });
                var record = await reader.SingleAsync();
                return record["m.response"].As<string>();
            });
            log.LogInformation($"[GraphMemory] Retrieved knowledge for '{query}': {result}");
            return result;
        }
    }

public static class MultiTurnMemory
{
    private static Dictionary<string, List<string>> _sessionMemory = new();

    [FunctionName("StoreUserSession")]
    public static void StoreUserSession([ActivityTrigger] string userId, string message, ILogger log)
    {
        if (!_sessionMemory.ContainsKey(userId))
            _sessionMemory[userId] = new List<string>();

        _sessionMemory[userId].Add(message);
        log.LogInformation($"[Session] Stored message for {userId}: {message}");
    }

    [FunctionName("RetrieveUserSession")]
    public static List<string> RetrieveUserSession([ActivityTrigger] string userId, ILogger log)
    {
        if (_sessionMemory.TryGetValue(userId, out var messages))
        {
            log.LogInformation($"[Session] Retrieved session for {userId}: {string.Join(", ", messages)}");
            return messages;
        }

        log.LogInformation($"[Session] No session found for {userId}");
        return new List<string>();
    }

using System;
using System.Collections.Generic;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;

public static class WebSocketHandler
{
    private static Dictionary<string, WebSocket> _activeSockets = new();

    [FunctionName("WebSocketHandler")]
    public static async Task WebSocketFunction([HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequest req,
        ILogger log)
    {
        if (!req.HttpContext.WebSockets.IsWebSocketRequest)
        {
            log.LogError("Invalid WebSocket request.");
            return;
        }

        var socket = await req.HttpContext.WebSockets.AcceptWebSocketAsync();
        string connectionId = Guid.NewGuid().ToString();
        _activeSockets[connectionId] = socket;

        log.LogInformation($"WebSocket connection established: {connectionId}");

        await HandleWebSocketConnection(socket, connectionId, log);
    }

    private static async Task HandleWebSocketConnection(WebSocket socket, string connectionId, ILogger log)
    {
        var buffer = new byte[1024 * 4];

        while (socket.State == WebSocketState.Open)
        {
            var result = await socket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
            if (result.MessageType == WebSocketMessageType.Close)
            {
                log.LogInformation($"WebSocket {connectionId} closed.");
                _activeSockets.Remove(connectionId);
                await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Session Ended", CancellationToken.None);
            }
            else
            {
                string receivedMessage = Encoding.UTF8.GetString(buffer, 0, result.Count);
                log.LogInformation($"Received message: {receivedMessage}");

                // Process the input and send back AI-generated response
                string aiResponse = await GenerateAIResponse(receivedMessage, log);
                var responseBuffer = Encoding.UTF8.GetBytes(aiResponse);

                await socket.SendAsync(new ArraySegment<byte>(responseBuffer, 0, responseBuffer.Length),
                    WebSocketMessageType.Text, true, CancellationToken.None);
            }
        }
    }

    private static async Task<string> GenerateAIResponse(string message, ILogger log)
    {
        return await Task.FromResult($"AI Response: {message} (processed in real-time)");
    }
}