pages/NeuralAgents.py

import os
import sqlite3
import websockets
import json
import asyncio
import time
import conteneiro
import streamlit as st
from io import StringIO
from agents import Llama2, Copilot, ChatGPT, Claude3, ForefrontAI, Flowise, Chaindesk, CharacterAI

st.set_page_config(layout="wide")

servers = []
clients = []
inputs = []
outputs = []
used_ports = []
credentials = []
server_ports = []
client_ports = []

# Set up the SQLite database
db = sqlite3.connect('chat-hub.db')
db.execute('CREATE TABLE IF NOT EXISTS messages (id INTEGER PRIMARY KEY AUTOINCREMENT, sender TEXT, message TEXT, timestamp TEXT)')

async def main():

    if "googleAPI" not in st.session_state:
        st.session_state.googleAPI = ""        
    if "cseID" not in st.session_state:
        st.session_state.cseID = ""                        
    if "api_key" not in st.session_state:
        st.session_state.api_key = "" 
    if "fireworks_api" not in st.session_state:
        st.session_state.fireworks_api = ""
    if "anthropicAPI" not in st.session_state:
        st.session_state.anthropicAPI = ""
    if "server_ports" not in st.session_state:
        st.session_state['server_ports'] = ""
    if "client_ports" not in st.session_state:
        st.session_state['client_ports'] = ""
    if "servers" not in st.session_state:
        st.session_state['servers'] = ""
    if "clients" not in st.session_state:
        st.session_state['clients'] = ""
    if "gradio_Port" not in st.session_state:
        st.session_state.gradio_Port = "" 
    if "server" not in st.session_state:
        st.session_state.server = False    
    if "client" not in st.session_state:
        st.session_state.client = False
    if "user_ID" not in st.session_state:
        st.session_state.user_ID = ""
    if "gradio_Port" not in st.session_state:
        st.session_state.gradio_Port = ""         
    if "forefront_api" not in st.session_state:
        st.session_state.forefront_api = ""
    if "tokenChar" not in st.session_state:
        st.session_state.tokenChar = ""
    if "charName" not in st.session_state:
        st.session_state.charName = ""
    if "character_ID" not in st.session_state:
        st.session_state.character_ID = ""
    if "flow" not in st.session_state:
        st.session_state.flow = ""
    if "agentID" not in st.session_state:
        st.session_state.agentID = ""
    if "tokens" not in st.session_state:
        st.session_state.tokens = None
    if 'credentials' not in st.session_state:
        st.session_state.credentials = []
    if "server_state" not in st.session_state:
        st.session_state.server_state = "complete"
    if "client_state" not in st.session_state:
        st.session_state.client_state = "complete"    
     
    APItokens = {
        "APIfireworks": str(st.session_state.fireworks_api),
        "APIforefront": str(st.session_state.forefront_api),
        "APIanthropic": str(st.session_state.anthropicAPI),
        "TokenCharacter": str(st.session_state.tokenChar),
        "char_ID": str(st.session_state.character_ID),
        "chaindeskID": str(st.session_state.agentID),
        "FlowiseID": str(st.session_state.flow)
    }

    json_credentials = json.dumps(APItokens)
    print(json_credentials)

    userInput = st.chat_input("Ask Agent")

    with st.expander("Personal API tokens"):
        uploadAPI = st.file_uploader(label="Upload credentials")
        fire = st.empty()        
        fore = st.empty()        
        anthro = st.empty()
        char = st.empty()        
        charID = st.empty()        
        chain = st.empty()        
        flo = st.empty()
        saveAPI = st.download_button(label="Download API tokens",
                        data=json_credentials,
                        file_name=f"APItokens.json",
                        mime="application/json",
                        help="Click to save your API keys")

        if st.session_state.tokens == None:
            fireworks_api = fire.text_input("Fireworks API")
            forefront_api = fore.text_input("Forefront AI API")
            anthropic_api = anthro.text_input("Anthropic API")
            characterToken = char.text_input("Character.ai personal token")
            character_ID = charID.text_input("Character ID")
            chaindeskAgent = chain.text_input("Chaindesk agent ID")
            flowID = flo.text_input("Flowise flow ID")

    c1, c2 = st.columns(2)

    selectAgent = st.selectbox("Select agent", ("Llama2", "Copilot", "ChatGPT", "Forefront AI", "Claude-3", "Character.ai", "Chaindesk", "Flowise"))
      
    with c1:
        websocketPort = st.number_input("Websocket server port", min_value=1000, max_value=9999, value=1000)   
        startServer = st.button("Start server")
        stopServer = st.button("Stop server")
        st.text("Servers")
        serverPorts1 = st.empty()
        serverPorts = serverPorts1.status(label="websocket servers", state="complete", expanded=False)
        serverPorts.write(conteneiro.servers)
    
    with c2:
        clientPort = st.number_input("Websocket client port", min_value=1000, max_value=9999, value=1000)
        runClient = st.button("Start client")
        stopClient = st.button("Stop client")        
        st.text("Websocket clients")
        clientPorts1 = st.empty()
        clientPorts = clientPorts1.status(label="websocket clients", state="complete", expanded=False)
        clientPorts.write(conteneiro.clients)

    with st.sidebar:
        # Wyświetlanie danych, które mogą być modyfikowane na różnych stronach       
        st.text("Websocket servers")
        srv_status = st.empty()
        server_status1 = srv_status.status(label="websocket servers", state="complete", expanded=True)
        server_status1.write(conteneiro.servers)
        if st.session_state.server == True:
            st.session_state.server_state = "running"
            srv_status.empty()
            server_status1 = srv_status.status(label="websocket servers", state=st.session_state.server_state, expanded=True)
            server_status1.write(conteneiro.servers)

        st.text("Websocket clients")
        cli_status = st.empty()
        client_status1 = cli_status.status(label="websocket clients", state="complete", expanded=True)
        client_status1.write(conteneiro.clients)
        if st.session_state.client == True:
            st.session_state.client_state = "running"
            cli_status.empty()
            client_status1 = cli_status.status(label="websocket clients", state=st.session_state.client_state, expanded=True)
            client_status1.write(conteneiro.clients)

    if uploadAPI is not None:

        data = json.load(uploadAPI)
        print(data)

        st.session_state.fireworks_api = data["APIfireworks"]
        
        if st.session_state.fireworks_api == "":
            fireworks_api = fire.text_input("Fireworks API key")
        else:
            fireworks_api = fire.container(border=True)
            fireworks_api.write(str(st.session_state.fireworks_api))

        st.session_state.forefront_api = data["APIforefront"]
        
        if  st.session_state.forefront_api == "":
            forefront_api = fore.text_input("Forefront API key")
        else:
            forefront_api = fore.container(border=True)
            forefront_api.write(str(st.session_state.forefront_api))

        st.session_state.anthropicAPI = data["APIanthropic"]

        if st.session_state.anthropicAPI == "":
            anthropic_api = anthro.text_input("Anthropic API key")
        else:
            anthropic_api = anthro.container(border=True)
            anthropic_api.write(str(st.session_state.anthropicAPI))

        st.session_state.tokenChar = data["TokenCharacter"]

        if st.session_state.tokenChar == "":
            characterToken = char.text_input("Character.ai user token")
        else:
            characterToken = char.container(border=True)
            characterToken.write(str(st.session_state.tokenChar))

        st.session_state.character_ID = data["char_ID"]

        if st.session_state.character_ID == "":
            character_ID = charID.text_input("Your Character ID")
        else:
            character_ID = charID.container(border=True)
            character_ID.write(str(st.session_state.character_ID))

        st.session_state.agentID = data["chaindeskID"]

        if st.session_state.agentID == "":
            chaindeskAgent = chain.text_input("Chaindesk agent ID:")
        else:
            chaindeskAgent = chain.container(border=True)
            chaindeskAgent.write(str(st.session_state.agentID))

        st.session_state.flow = data["FlowiseID"]

        if st.session_state.flow == "":
            flowID = flo.text_input("Flowise flow ID:")
        else:
            flowID = flo.container(border=True)
            flowID.write(str(st.session_state.flow))

    if saveAPI:
        credentials.clear()
        st.session_state.fireworks_api = fireworks_api
        credentials.append(st.session_state.fireworks_api)
        st.session_state.forefront_api = forefront_api
        credentials.append(st.session_state.forefront_api)
        st.session_state.anthropicAPI = anthropic_api
        credentials.append(st.session_state.anthropicAPI)
        st.session_state.tokenChar = characterToken
        credentials.append(st.session_state.tokenChar)
        st.session_state.character_ID = character_ID
        credentials.append(st.session_state.character_ID)
        st.session_state.agentID = chaindeskAgent
        credentials.append(st.session_state.agentID)
        st.session_state.flow = flowID
        credentials.append(st.session_state.flow)

    if  selectAgent == "Llama2":

        if userInput:
            print(f"User B: {userInput}")
            user_input = st.chat_message("human")
            user_input.markdown(userInput)
            agent = Llama2(str(st.session_state.fireworks_api))
            results = await agent.handleInput(userInput)
            print(results)

        if runClient:
            st.session_state.client = True
            cli_name = f"Llama2 client port: {clientPort}"
            cli_status.empty()
            client_status1 = cli_status.status(label=cli_name, state="running", expanded=True)
            client_status1.write(conteneiro.clients)
            clientPorts1.empty()            
            clientPorts = clientPorts1.status(label=cli_name, state="running", expanded=True)
            clientPorts.write(conteneiro.clients)            
            try:
                client = Llama2(str(st.session_state.fireworks_api))             
                await client.startClient(clientPort)
                print(f"Connecting client on port {clientPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")              

        if startServer:
            st.session_state.server = True
            srv_name = f"Llama2 server port: {websocketPort}"
            srv_status.empty()
            server_status1 = srv_status.status(label=srv_name, state="running", expanded=True)
            server_status1.write(conteneiro.servers)
            serverPorts1.empty()
            serverPorts = serverPorts1.status(label=srv_name, state="running", expanded=True)
            serverPorts.write(conteneiro.servers)            
            try:
                server = Llama2(str(st.session_state.fireworks_api))              
                await server.start_server(websocketPort)
                print(f"Starting WebSocket server on port {websocketPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")

    if  selectAgent == "Copilot":

        if userInput:
            print(f"User B: {userInput}")
            user_input = st.chat_message("human")
            user_input.markdown(userInput)
            agent = Copilot()
            results = await agent.handleInput(userInput)
            print(results)

        if runClient:
            st.session_state.client = True
            cli_name1 = f"Copilot client port: {clientPort}"
            cli_status.empty()
            client_status1 = cli_status.status(label=cli_name1, state="running", expanded=True)
            client_status1.write(conteneiro.clients)
            clientPorts1.empty()            
            clientPorts = clientPorts1.status(label=cli_name1, state="running", expanded=True)
            clientPorts.write(conteneiro.clients)            
            try:
                client = Copilot()
                await client.startClient(clientPort)
                print(f"Connecting client on port {clientPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")              

        if startServer:
            st.session_state.server = True
            srv_name1 = f"Copilot server port: {websocketPort}"
            srv_status.empty()
            server_status1 = srv_status.status(label="websocket servers", state="running", expanded=True)
            server_status1.write(conteneiro.servers)
            serverPorts1.empty()
            serverPorts = serverPorts1.status(label="websocket servers", state="running", expanded=True)
            serverPorts.write(conteneiro.servers)            
            try:
                server = Copilot()
                await server.start_server(websocketPort)
                print(f"Starting WebSocket server on port {websocketPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")

    if  selectAgent == "ChatGPT":

        if userInput:
            print(f"User B: {userInput}")
            user_input = st.chat_message("human")
            user_input.markdown(userInput)
            agent = ChatGPT()
            results = await agent.handleInput(userInput)
            print(results)

        if runClient:
            st.session_state.client = True
            cli_name2 = f"GPT-3,5 client port: {clientPort}"
            cli_status.empty()
            client_status1 = cli_status.status(label=cli_name2, state="running", expanded=True)
            client_status1.write(conteneiro.clients)
            clientPorts1.empty()            
            clientPorts = clientPorts1.status(label=cli_name2, state="running", expanded=True)
            clientPorts.write(conteneiro.clients)            
            try:
                client = ChatGPT()         
                await client.startClient(clientPort)
                print(f"Connecting client on port {clientPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")              

        if startServer:
            st.session_state.server = True
            srv_name2 = f"GPT-3,5 server port: {websocketPort}"
            srv_status.empty()
            server_status1 = srv_status.status(label=srv_name2, state="running", expanded=True)
            server_status1.write(conteneiro.servers)
            serverPorts1.empty()
            serverPorts = serverPorts1.status(label=srv_name2, state="running", expanded=True)
            serverPorts.write(conteneiro.servers)            
            try:
                server = ChatGPT()
                await server.start_server(websocketPort)
                print(f"Starting WebSocket server on port {websocketPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")

    if  selectAgent == "Forefront AI":

        if userInput:
            print(f"User B: {userInput}")
            user_input = st.chat_message("human")
            user_input.markdown(userInput)
            agent = ForefrontAI(str(st.session_state.forefront_api))
            results = await agent.handleInput(userInput)
            print(results)

        if runClient:
            st.session_state.client = True
            cli_name = f"Forefront AI client port: {clientPort}"
            cli_status.empty()
            client_status1 = cli_status.status(label=cli_name, state="running", expanded=True)
            client_status1.write(conteneiro.clients)
            clientPorts1.empty()            
            clientPorts = clientPorts1.status(label=cli_name, state="running", expanded=True)
            clientPorts.write(conteneiro.clients)            
            try:
                client = ForefrontAI(str(st.session_state.forefront_api))        
                await client.startClient(clientPort)
                print(f"Connecting client on port {clientPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")              

        if startServer:
            st.session_state.server = True
            srv_name = f"Forefroont AI server port: {websocketPort}"
            srv_status.empty()
            server_status1 = srv_status.status(label=srv_name, state="running", expanded=True)
            server_status1.write(conteneiro.servers)
            serverPorts1.empty()
            serverPorts = serverPorts1.status(label=srv_name, state="running", expanded=True)
            serverPorts.write(conteneiro.servers)            
            try:
                server = ForefrontAI(str(st.session_state.forefront_api))
                await server.start_server(websocketPort)
                print(f"Starting WebSocket server on port {websocketPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")

    if  selectAgent == "Claude-3":

        if userInput:
            print(f"User B: {userInput}")
            user_input = st.chat_message("human")
            user_input.markdown(userInput)
            agent = Claude3(str(st.session_state.anthropicAPI))
            results = await agent.handleInput(userInput)
            print(results)

        if runClient:
            st.session_state.client = True
            cli_name = f"Claude-3 client port: {clientPort}"
            cli_status.empty()
            client_status1 = cli_status.status(label=cli_name, state="running", expanded=True)
            client_status1.write(conteneiro.clients)
            clientPorts1.empty()            
            clientPorts = clientPorts1.status(label=cli_name, state="running", expanded=True)
            clientPorts.write(conteneiro.clients)            
            try:
                client = Claude3(str(st.session_state.anthropicAPI))
                await client.startClient(clientPort)
                print(f"Connecting client on port {clientPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")              

        if startServer:
            st.session_state.server = True
            srv_name = f"Claude-3 server port: {websocketPort}"
            srv_status.empty()
            server_status1 = srv_status.status(label=srv_name, state="running", expanded=True)
            server_status1.write(conteneiro.servers)
            serverPorts1.empty()
            serverPorts = serverPorts1.status(label=srv_name, state="running", expanded=True)
            serverPorts.write(conteneiro.servers)            
            try:
                server = Claude3(str(st.session_state.anthropicAPI))        
                await server.start_server(websocketPort)
                print(f"Starting WebSocket server on port {websocketPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")

    if  selectAgent == "Character.ai":

        usrToken = str(st.session_state.tokenChar)
        charID = str(st.session_state.character_ID)

        if userInput:
            print(f"User B: {userInput}")
            user_input = st.chat_message("human")
            user_input.markdown(userInput)
            agent = CharacterAI(usrToken, charID)
            results = await agent.handleInput(userInput)
            print(results)

        if runClient:
            st.session_state.client = True
            cli_name = f"Claude-3 client port: {clientPort}"
            cli_status.empty()
            client_status1 = cli_status.status(label=cli_name, state="running", expanded=True)
            client_status1.write(conteneiro.clients)
            clientPorts1.empty()            
            clientPorts = clientPorts1.status(label=cli_name, state="running", expanded=True)
            clientPorts.write(conteneiro.clients)            
            try:
                client = CharacterAI(usrToken, charID)
                await client.startClient(clientPort)
                print(f"Connecting client on port {clientPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")              

        if startServer:
            st.session_state.server = True
            srv_name = f"Claude-3 server port: {websocketPort}"
            srv_status.empty()
            server_status1 = srv_status.status(label=srv_name, state="running", expanded=True)
            server_status1.write(conteneiro.servers)
            serverPorts1.empty()
            serverPorts = serverPorts1.status(label=srv_name, state="running", expanded=True)
            serverPorts.write(conteneiro.servers)            
            try:
                server = CharacterAI(usrToken, charID)
                await server.start_server(websocketPort)
                print(f"Starting WebSocket server on port {websocketPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")

    if  selectAgent == "Chaindesk":

        if userInput:
            print(f"User B: {userInput}")
            user_input = st.chat_message("human")
            user_input.markdown(userInput)
            agent = Chaindesk(str(st.session_state.agentID))   
            results = await agent.handleInput(userInput)
            print(results)

        if runClient:
            st.session_state.client = True
            cli_name = f"Claude-3 client port: {clientPort}"
            cli_status.empty()
            client_status1 = cli_status.status(label=cli_name, state="running", expanded=True)
            client_status1.write(conteneiro.clients)
            clientPorts1.empty()            
            clientPorts = clientPorts1.status(label=cli_name, state="running", expanded=True)
            clientPorts.write(conteneiro.clients)            
            try:
                client = Chaindesk(str(st.session_state.agentID))
                await client.startClient(clientPort)
                print(f"Connecting client on port {clientPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")              

        if startServer:
            st.session_state.server = True
            srv_name = f"Claude-3 server port: {websocketPort}"
            srv_status.empty()
            server_status1 = srv_status.status(label=srv_name, state="running", expanded=True)
            server_status1.write(conteneiro.servers)
            serverPorts1.empty()
            serverPorts = serverPorts1.status(label=srv_name, state="running", expanded=True)
            serverPorts.write(conteneiro.servers)            
            try:
                server = Chaindesk(str(st.session_state.agentID))
                await server.start_server(websocketPort)
                print(f"Starting WebSocket server on port {websocketPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")

    if  selectAgent == "Flowise":

        if userInput:
            print(f"User B: {userInput}")
            user_input = st.chat_message("human")
            user_input.markdown(userInput)
            agent = Flowise(str(st.session_state.flow))
            results = await agent.handleInput(userInput)
            print(results)

        if runClient:
            st.session_state.client = True
            cli_name = f"Claude-3 client port: {clientPort}"
            cli_status.empty()
            client_status1 = cli_status.status(label=cli_name, state="running", expanded=True)
            client_status1.write(conteneiro.clients)
            clientPorts1.empty()            
            clientPorts = clientPorts1.status(label=cli_name, state="running", expanded=True)
            clientPorts.write(conteneiro.clients)            
            try:
                client = Flowise(str(st.session_state.flow))
                await client.startClient(clientPort)
                print(f"Connecting client on port {clientPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")              

        if startServer:
            st.session_state.server = True
            srv_name = f"Claude-3 server port: {websocketPort}"
            srv_status.empty()
            server_status1 = srv_status.status(label=srv_name, state="running", expanded=True)
            server_status1.write(conteneiro.servers)
            serverPorts1.empty()
            serverPorts = serverPorts1.status(label=srv_name, state="running", expanded=True)
            serverPorts.write(conteneiro.servers)            
            try:
                server = Flowise(str(st.session_state.flow))
                await server.start_server(websocketPort)
                print(f"Starting WebSocket server on port {websocketPort}...")
                await asyncio.Future()

            except Exception as e:
                print(f"Error: {e}")

asyncio.run(main())