do_art.md

class BatchRunner:
     def __init__(self):
        # stworzenie klasy z miejscem na przechowywanie funkcji
        self.functions = {}

    def add_function(self, name, function_definition):
        # dodawanie funkcji do runnera

    @staticmethod
    def run_batch(
        functions_dict,
        params_dict,
        batch_size: int = 10):
        # wykonanie logiki dla batcha funkcji i paramterów 

# przykładowe użycie BatchRunner

functions_dict = {
    "action_first": action_first, # dowolna funkcja action_first
    "action_second": action_second 
}

params_dict = {
    "action_first": ((x, y), {}), # parametry do dowolnej funkcji action_first
    "action_second": ((a, b), {}),
}

# wszystkie wyniki w formie słownika 
results = BatchFunction.run_batch(
    functions_dict, params_dict, batch_size=2)

class ConversationController:
    def __init__(self, assistant_config):
        self.msgs = []
        # stworzenie klasy z odpowiednią konfiguracją asystenta
    
    def user(self, message):
        # dodawanie wiadomości usera

    def assistant(self, message):
        # dodawanie wiadomości asystenta 

    def response(self, mode='text'):
        # tworzenie odpowiedzi w api w oparciu 
        # o strukturę wiadomości wysyłaną do modelu

# przykładowe użycie ConversationController

# wytworzenie instancji
cc = ConversationController(assistant_config)

# wytworzenie odpowiedzi wg wzorca builder
response = cc.user(...).assistant(...).user(...).response()

# tworzenie awatara do rozmowy
avatar = ConversationController(
     avatar_generator_config
     ).assistant(
          "Alex, 22y, kierowca tira. Poziom hard"
     )

# generowanie początkowego opisu awatara
avatar_description = avatar.response()

# generowanie sytuacji w oparciu o awatara
situation_description = ConversationController(
     situation_generator_config
     ).assistant(
          f"Na podstawie charakterystyki awatara: {avatar_description}"
     ).response()

# tworzenie modelu obserwującego agendę
meeting_agenda = ConversationController(
     agenda_generator_config
     ).assistant(f"Na podstawie sytuacji: {situation_description}")

# generowanie wejściowej agendy
initial_agenda = meeting_agenda.response()

# tworzenie modelu obserwującego poziom stresu awatara
stress_meter = ConversationController(
     stress_meter_config
     ).assistant(
          f"Na podstawie charakterystyki awatara: {avatar_description}")

# generowanie wejściowego stresu awatara
initial_stress_meter = stress_meter.response()

# miejsce na odpowiedz od agenta
def get_agent_response()
    # oczekiwanie na odpowiedz użytkownika w UI

# pokazywanie kolejnego kroku do agenta
def show_env(avatar, meeting_agenda, stress_meter, user_response)
    # poinformowanie agenta o reakcji środowiska na to co napisał

# dokonujemy interakcji odpowiedzią agenta ze środowiskiem
def interact_with_next_user_response(
     avatar, meeting_agenda, stress_meter, user_response
     ):

    # dodajemy reakcję agenta
    avatar.user(user_response)
    meeting_agenda.user(user_response)
    stress_meter.user(user_response)

    # pakujemy controllery w flow równoległy
    functions_dict = {
        "avatar": avatar.response,  
        "meeting_agenda": meeting_agenda.response,  
        "stress_meter": stress_meter.response,  
    }

    params_dict = {
        "avatar": ((), {}),
        "meeting_agenda": ((), {}),
        "stress_meter": ((), {}),
    }

    # wywołujemy paczkę równoległych działań
    results = BatchFunction.run_batch(
        functions_dict, params_dict, batch_size=2)

    return results

# makieta działania środowiska
def show_next_env_response(
     avatar, meeting_agenda, stress_meter, user_response):
 
    # interakcja ze środowiskiem
    results = interact_with_next_user_response(
          avatar, meeting_agenda, stress_meter, user_response)

    # odzyskujemy odpowiedzi z flow równoległego w potrzebnym formacie
    next_avatar_reaction = results["avatar"]
    next_agenda = results["meeting_agenda"].json()
    next_stress_meter = results["stress_meter"].integer()

    if stress_meter == 10:
        # jeśli agent wygenerował stress na poziomie 10 - koniec symulacji

    all_objectives_completed = all(
          [objective['complete'] for objective in next_agenda])

    if all_objectives_completed:
        # jeśli agent zaliczył wszystkie cele agendy - wygrywa symulację

        if stress_meter <= 2:
            # jeśli agent zaliczył wszystkie cele agendy 
            # i zmniejszył poziom stresu do 2 - wygrywa cel opcjonalny 


    # pokazujemy agentowi rezulta
    show_env(next_avatar_reaction, next_agenda, next_stress_meter)

    # jeśli symulacja się nie zakończyła to czekamy na odpowiedz 
    next_user_response = get_agent_response()

    # gramy dalej!
    return show_next_env_response(
        avatar, meeting_agenda, 
        stress_meter, next_user_response)