Upload folder using huggingface_hub

README.md

@@ -3,8 +3,9 @@ title: Tiny Factory
 emoji: 💻
 colorFrom: yellow
 colorTo: gray
-sdk: docker
-app_port: 7860
+sdk: gradio
+sdk_version: 6.3.0
+app_file: app.py
 pinned: false
 ---
 

app.py

@@ -2,13 +2,46 @@ import sys
 import os
 import gradio as gr
 import json
-import random
 from tinytroupe.factory import TinyPersonFactory
-from tinytroupe.simulation_manager import SimulationConfig
-from tinytroupe.content_generation import ContentVariantGenerator
-from tinytroupe.agent_types import Content
-from api.main import app, simulation_manager
-import uvicorn
+from tinytroupe.utils.semantics import select_best_persona
+from tinytroupe.simulation_manager import SimulationManager, SimulationConfig
+from tinytroupe.agent.social_types import Content
+from huggingface_hub import hf_hub_download, upload_file
+
+HF_TOKEN = os.getenv("HF_TOKEN") # Ensure this is set in Space secrets
+REPO_ID = "harvesthealth/tiny_factory"
+PERSONA_BASE_FILE = "persona_base.json"
+
+simulation_manager = SimulationManager()
+
+def load_persona_base():
+    if not HF_TOKEN:
+        print("HF_TOKEN not found, persistence disabled.")
+        return []
+    try:
+        path = hf_hub_download(repo_id=REPO_ID, filename=PERSONA_BASE_FILE, repo_type="space", token=HF_TOKEN)
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"Error loading persona base: {e}")
+        return []
+
+def save_persona_base(personas):
+    if not HF_TOKEN:
+        print("HF_TOKEN not found, skipping upload.")
+        return
+    with open(PERSONA_BASE_FILE, 'w', encoding='utf-8') as f:
+        json.dump(personas, f, indent=4)
+    try:
+        upload_file(
+            path_or_fileobj=PERSONA_BASE_FILE,
+            path_in_repo=PERSONA_BASE_FILE,
+            repo_id=REPO_ID,
+            repo_type="space",
+            token=HF_TOKEN
+        )
+    except Exception as e:
+        print(f"Error saving persona base to Hub: {e}")
 
 # --- CHANGE 1: The function now accepts an optional API key. ---
 def generate_personas(business_description, customer_profile, num_personas, blablador_api_key=None):
@@ -17,197 +50,391 @@ def generate_personas(business_description, customer_profile, num_personas, blab
     It prioritizes the API key passed as an argument, but falls back to the
     environment variable if none is provided (for UI use).
     """
+    # --- CHANGE 2: Logic to determine which key to use. ---
+    # Use the key from the API call if provided, otherwise get it from the Space secrets.
     api_key_to_use = blablador_api_key or os.getenv("BLABLADOR_API_KEY")
 
     if not api_key_to_use:
         return {"error": "BLABLADOR_API_KEY not found. Please provide it in your API call or set it as a secret in the Space settings."}
 
+    # Store the original state of the environment variable, if it exists
     original_key = os.getenv("BLABLADOR_API_KEY")
     
     try:
+        # --- CHANGE 3: Securely set the correct environment variable for this request. ---
+        # The underlying tinytroupe library will look for this variable.
         os.environ["BLABLADOR_API_KEY"] = api_key_to_use
+
         num_personas = int(num_personas)
+
         factory = TinyPersonFactory(
             context=business_description,
             sampling_space_description=customer_profile,
             total_population_size=num_personas
         )
+
         people = factory.generate_people(number_of_people=num_personas, parallelize=False)
         personas_data = [person._persona for person in people]
+        
+        # --- NEW: Update the Tresor ---
+        current_base = load_persona_base()
+        current_base.extend(personas_data)
+        save_persona_base(current_base)
+        # ------------------------------
+
         return personas_data
+
     except Exception as e:
         return {"error": str(e)}
+
     finally:
+        # --- CHANGE 4: A robust cleanup using a 'finally' block. ---
+        # This ensures the environment is always restored to its original state,
+        # whether the function succeeds or fails.
         if original_key is None:
+            # If the variable didn't exist originally, remove it.
             if "BLABLADOR_API_KEY" in os.environ:
                 del os.environ["BLABLADOR_API_KEY"]
         else:
+            # If it existed, restore its original value.
             os.environ["BLABLADOR_API_KEY"] = original_key
 
-def create_simulation_ui(name, persona_count, network_type):
+
+def find_best_persona(criteria):
+    """
+    Loads the persona base and finds the best matching persona based on criteria.
+    """
+    personas = load_persona_base()
+    if not personas:
+        return {"error": "Persona base is empty. Generate some personas first!"}
+
+    try:
+        # select_best_persona uses LLM to find the best index
+        idx = select_best_persona(criteria=criteria, personas=personas)
+
+        try:
+            idx = int(idx)
+        except (ValueError, TypeError):
+            return {"error": f"LLM returned an invalid index: {idx}"}
+
+        if idx >= 0 and idx < len(personas):
+            return personas[idx]
+        else:
+            return {"error": f"No matching persona found for criteria: {criteria}"}
+    except Exception as e:
+        return {"error": f"Error during persona matching: {str(e)}"}
+
+
+def generate_social_network_api(name, persona_count, network_type, focus_group_name=None):
+    """
+    Gradio API endpoint for generating a social network.
+    """
     try:
         config = SimulationConfig(name=name, persona_count=int(persona_count), network_type=network_type)
-        sim = simulation_manager.create_simulation(config)
-        return {"status": "Simulation created", "id": sim.id, "persona_count": len(sim.personas)}
+        simulation = simulation_manager.create_simulation(config, focus_group_name=focus_group_name)
+        return {
+            "simulation_id": simulation.id,
+            "name": simulation.config.name,
+            "persona_count": len(simulation.personas),
+            "network_metrics": simulation.network.get_metrics()
+        }
     except Exception as e:
         return {"error": str(e)}
 
-def run_simulation_ui(simulation_id, content_text):
+
+def predict_engagement_api(simulation_id, content_text, format="text"):
+    """
+    Gradio API endpoint for predicting engagement.
+    """
     try:
-        if simulation_id not in simulation_manager.simulations:
-            return {"error": "Simulation not found"}
-        result = simulation_manager.run_simulation(simulation_id, content_text)
+        content = Content(text=content_text, format=format)
+        result = simulation_manager.run_simulation(simulation_id, content)
         return {
-            "simulation_id": simulation_id,
             "total_reach": result.total_reach,
-            "engagements": result.engagements
+            "expected_likes": result.expected_likes,
+            "expected_comments": result.expected_comments,
+            "expected_shares": result.expected_shares,
+            "execution_time": result.execution_time,
+            "avg_sentiment": result.avg_sentiment,
+            "feedback_summary": result.feedback_summary
         }
     except Exception as e:
         return {"error": str(e)}
 
-def predict_engagement_ui(persona_name, content_text, simulation_id):
+
+def start_simulation_async_api(simulation_id, content_text, format="text"):
+    """
+    Starts a simulation in the background.
+    """
     try:
-        if simulation_id not in simulation_manager.simulations:
-            return {"error": "Simulation not found"}
-        sim = simulation_manager.simulations[simulation_id]
-        persona = next((p for p in sim.personas if p.name == persona_name), None)
-        if not persona:
-            return {"error": "Persona not found"}
+        content = Content(text=content_text, format=format)
+        simulation_manager.run_simulation(simulation_id, content, background=True)
+        return {"status": "started", "simulation_id": simulation_id}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def get_simulation_status_api(simulation_id):
+    """
+    Checks the status and progress of a simulation.
+    """
+    try:
+        sim = simulation_manager.get_simulation(simulation_id)
+        if not sim: return {"error": "Simulation not found"}
         
-        content_obj = Content(text=content_text, content_type="post", topics=[], length=len(content_text), tone="")
-        prob = sim.world._simulate_engagement_decision(persona, content_obj, 0)
-        return {
-            "persona": persona_name,
-            "will_engage": prob.engaged,
-            "probability": prob.probability,
-            "comment": prob.comment
+        status_data = {
+            "status": sim.status,
+            "progress": sim.progress
         }
+        
+        if sim.status == "completed" and sim.last_result:
+            status_data["result"] = {
+                "total_reach": sim.last_result.total_reach,
+                "expected_likes": sim.last_result.expected_likes,
+                "avg_sentiment": sim.last_result.avg_sentiment
+            }
+            
+        return status_data
     except Exception as e:
         return {"error": str(e)}
 
-def generate_variants_ui(original_content, num_variants):
+
+def send_chat_message_api(simulation_id, sender, message):
+    """
+    Sends a message to the simulation chat.
+    """
     try:
-        variants = simulation_manager.variant_generator.generate_variants(original_content, int(num_variants))
-        return [v.__dict__ for v in variants]
+        return simulation_manager.send_chat_message(simulation_id, sender, message)
     except Exception as e:
         return {"error": str(e)}
 
-def get_metrics_ui(simulation_id):
+
+def get_chat_history_api(simulation_id):
+    """
+    Gets the chat history for a simulation.
+    """
     try:
-        if simulation_id not in simulation_manager.simulations:
-            return {"error": "Simulation not found"}
-        sim = simulation_manager.simulations[simulation_id]
-        from tinytroupe.network_analysis import NetworkAnalyzer
-        metrics = NetworkAnalyzer.calculate_centrality_metrics(sim.network)
-        influencers = NetworkAnalyzer.identify_key_influencers(sim.network)
-        return {
-            "density": NetworkAnalyzer.calculate_density(sim.network),
-            "key_influencers": influencers,
-            "centrality_metrics": metrics
-        }
+        return simulation_manager.get_chat_history(simulation_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def generate_variants_api(content_text, num_variants):
+    """
+    Gradio API endpoint for generating content variants.
+    """
+    try:
+        variants = simulation_manager.variant_generator.generate_variants(content_text, num_variants=int(num_variants))
+        return [{"text": v.text, "strategy": v.strategy} for v in variants]
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def list_simulations_api():
+    """
+    Gradio API endpoint for listing simulations.
+    """
+    try:
+        return simulation_manager.list_simulations()
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def list_personas_api(simulation_id):
+    """
+    Gradio API endpoint for listing personas in a simulation.
+    """
+    try:
+        return simulation_manager.list_personas(simulation_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def get_persona_api(simulation_id, persona_name):
+    """
+    Gradio API endpoint for getting persona details.
+    """
+    try:
+        return simulation_manager.get_persona(simulation_id, persona_name)
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def delete_simulation_api(simulation_id):
+    """
+    Gradio API endpoint for deleting a simulation.
+    """
+    try:
+        success = simulation_manager.delete_simulation(simulation_id)
+        return {"success": success}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def export_simulation_api(simulation_id):
+    """
+    Gradio API endpoint for exporting a simulation.
+    """
+    try:
+        return simulation_manager.export_simulation(simulation_id)
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def list_focus_groups_api():
+    """
+    Gradio API endpoint for listing focus groups.
+    """
+    try:
+        return simulation_manager.list_focus_groups()
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def save_focus_group_api(name, simulation_id):
+    """
+    Gradio API endpoint for saving a focus group from a simulation.
+    """
+    try:
+        sim = simulation_manager.get_simulation(simulation_id)
+        if not sim: return {"error": "Simulation not found"}
+        simulation_manager.save_focus_group(name, sim.personas)
+        return {"status": "success", "name": name}
     except Exception as e:
         return {"error": str(e)}
 
 
 with gr.Blocks() as demo:
-    gr.Markdown("<h1>Tiny Factory & Artificial Societies</h1>")
-    
-    with gr.Tabs():
-        with gr.Tab("Persona Generation"):
-            with gr.Row():
-                with gr.Column():
-                    business_description_input = gr.Textbox(label="What is your business about?", lines=5)
-                    customer_profile_input = gr.Textbox(label="Information about your customer profile", lines=5)
-                    num_personas_gen_input = gr.Number(label="Number of personas to generate", value=1, minimum=1, step=1)
-                    blablador_api_key_input = gr.Textbox(label="Blablador API Key (for API client use)", visible=False)
-                    generate_personas_button = gr.Button("Generate Personas")
-                with gr.Column():
-                    gen_personas_output = gr.JSON(label="Generated Personas")
+    gr.Markdown("<h1>Tiny Persona Generator</h1>")
+    with gr.Row():
+        with gr.Column():
+            business_description_input = gr.Textbox(label="What is your business about?", lines=5)
+            customer_profile_input = gr.Textbox(label="Information about your customer profile", lines=5)
+            num_personas_input = gr.Number(label="Number of personas to generate", value=1, minimum=1, step=1)
             
-            generate_personas_button.click(
-                fn=generate_personas,
-                inputs=[business_description_input, customer_profile_input, num_personas_gen_input, blablador_api_key_input],
-                outputs=gen_personas_output,
-                api_name="generate_personas"
+            # --- CHANGE 5: The API key input is now INVISIBLE. ---
+            # It still exists, so the API endpoint is created, but it's hidden from UI users.
+            blablador_api_key_input = gr.Textbox(
+                label="Blablador API Key (for API client use)", 
+                visible=False
             )
 
-        with gr.Tab("Social Simulation"):
-            with gr.Row():
-                with gr.Column():
-                    sim_name_input = gr.Textbox(label="Simulation Name", value="My Social Simulation")
-                    sim_persona_count = gr.Number(label="Number of Personas", value=10, minimum=1, step=1)
-                    sim_network_type = gr.Dropdown(label="Network Type", choices=["scale_free", "professional"], value="scale_free")
-                    create_sim_button = gr.Button("Create Simulation")
-                    
-                    sim_content_input = gr.Textbox(label="Content to Test", lines=3)
-                    sim_id_run_input = gr.Textbox(label="Simulation ID (to run)")
-                    run_sim_button = gr.Button("Run Content Spread Simulation")
-                with gr.Column():
-                    sim_output = gr.JSON(label="Simulation Status/Results")
-
-            create_sim_button.click(
-                fn=create_simulation_ui,
-                inputs=[sim_name_input, sim_persona_count, sim_network_type],
-                outputs=sim_output,
-                api_name="create_simulation"
-            )
-            run_sim_button.click(
-                fn=run_simulation_ui,
-                inputs=[sim_id_run_input, sim_content_input],
-                outputs=sim_output,
-                api_name="run_simulation"
-            )
+            generate_button = gr.Button("Generate Personas")
 
-        with gr.Tab("Engagement Prediction"):
-            with gr.Row():
-                with gr.Column():
-                    pred_persona_name = gr.Textbox(label="Persona Name")
-                    pred_content = gr.Textbox(label="Content Text", lines=3)
-                    pred_sim_id = gr.Textbox(label="Simulation ID")
-                    predict_button = gr.Button("Predict Engagement")
-                with gr.Column():
-                    pred_output = gr.JSON(label="Prediction Result")
-            
-            predict_button.click(
-                fn=predict_engagement_ui,
-                inputs=[pred_persona_name, pred_content, pred_sim_id],
-                outputs=pred_output,
-                api_name="predict_engagement"
-            )
+            gr.Markdown("---")
+            gr.Markdown("<h3>Search Tresor</h3>")
+            criteria_input = gr.Textbox(label="Criteria to find best matching persona", lines=2)
+            find_button = gr.Button("Find Best Persona in Tresor")
 
-        with gr.Tab("Content Engine"):
-            with gr.Row():
-                with gr.Column():
-                    cont_original = gr.Textbox(label="Original Content", lines=5)
-                    cont_num_variants = gr.Number(label="Number of Variants", value=5, minimum=1)
-                    generate_variants_button = gr.Button("Generate Variants")
-                with gr.Column():
-                    cont_output = gr.JSON(label="Content Variants")
-            
-            generate_variants_button.click(
-                fn=generate_variants_ui,
-                inputs=[cont_original, cont_num_variants],
-                outputs=cont_output,
-                api_name="generate_content_variants"
-            )
+        with gr.Column():
+            output_json = gr.JSON(label="Output (Generated or Matched Persona)")
 
-        with gr.Tab("Network Analytics"):
-            with gr.Row():
-                with gr.Column():
-                    metrics_sim_id = gr.Textbox(label="Simulation ID")
-                    get_metrics_button = gr.Button("Get Network Metrics")
-                with gr.Column():
-                    metrics_output = gr.JSON(label="Network Analytics")
-            
-            get_metrics_button.click(
-                fn=get_metrics_ui,
-                inputs=[metrics_sim_id],
-                outputs=metrics_output,
-                api_name="get_network_metrics"
-            )
+    generate_button.click(
+        fn=generate_personas,
+        # --- CHANGE 6: Pass the invisible textbox to the function. ---
+        inputs=[business_description_input, customer_profile_input, num_personas_input, blablador_api_key_input],
+        outputs=output_json,
+        api_name="generate_personas"
+    )
+
+    find_button.click(
+        fn=find_best_persona,
+        inputs=[criteria_input],
+        outputs=output_json,
+        api_name="find_best_persona"
+    )
+
+    # Invisible components to expose API endpoints
+    # These won't be seen by regular UI users but will be available via /api
+    with gr.Tab("Social Network API", visible=False):
+        api_net_name = gr.Textbox(label="Network Name")
+        api_net_count = gr.Number(label="Persona Count", value=10)
+        api_net_type = gr.Dropdown(choices=["scale_free", "small_world"], label="Network Type")
+        api_net_focus = gr.Textbox(label="Focus Group Name (optional)")
+        api_net_btn = gr.Button("Generate Network")
+        api_net_out = gr.JSON()
+        api_net_btn.click(generate_social_network_api, inputs=[api_net_name, api_net_count, api_net_type, api_net_focus], outputs=api_net_out, api_name="generate_social_network")
+
+    with gr.Tab("Engagement Prediction API", visible=False):
+        api_pred_sim_id = gr.Textbox(label="Simulation ID")
+        api_pred_content = gr.Textbox(label="Content Text")
+        api_pred_format = gr.Textbox(label="Format", value="text")
+        api_pred_btn = gr.Button("Predict Engagement")
+        api_pred_out = gr.JSON()
+        api_pred_btn.click(predict_engagement_api, inputs=[api_pred_sim_id, api_pred_content, api_pred_format], outputs=api_pred_out, api_name="predict_engagement")
+
+    with gr.Tab("Async Simulation API", visible=False):
+        api_async_sim_id = gr.Textbox(label="Simulation ID")
+        api_async_content = gr.Textbox(label="Content Text")
+        api_async_format = gr.Textbox(label="Format", value="text")
+        api_async_btn = gr.Button("Start Simulation")
+        api_async_out = gr.JSON()
+        api_async_btn.click(start_simulation_async_api, inputs=[api_async_sim_id, api_async_content, api_async_format], outputs=api_async_out, api_name="start_simulation_async")
+        
+        api_status_id = gr.Textbox(label="Simulation ID")
+        api_status_btn = gr.Button("Check Status")
+        api_status_out = gr.JSON()
+        api_status_btn.click(get_simulation_status_api, inputs=[api_status_id], outputs=api_status_out, api_name="get_simulation_status")
+
+    with gr.Tab("Chat API", visible=False):
+        api_chat_sim_id = gr.Textbox(label="Simulation ID")
+        api_chat_sender = gr.Textbox(label="Sender", value="User")
+        api_chat_msg = gr.Textbox(label="Message")
+        api_chat_send_btn = gr.Button("Send Message")
+        api_chat_send_out = gr.JSON()
+        api_chat_send_btn.click(send_chat_message_api, inputs=[api_chat_sim_id, api_chat_sender, api_chat_msg], outputs=api_chat_send_out, api_name="send_chat_message")
+        
+        api_chat_hist_btn = gr.Button("Get History")
+        api_chat_hist_out = gr.JSON()
+        api_chat_hist_btn.click(get_chat_history_api, inputs=[api_chat_sim_id], outputs=api_chat_hist_out, api_name="get_chat_history")
+
+    with gr.Tab("Content Variants API", visible=False):
+        api_var_content = gr.Textbox(label="Original Content")
+        api_var_count = gr.Number(label="Number of Variants", value=5)
+        api_var_btn = gr.Button("Generate Variants")
+        api_var_out = gr.JSON()
+        api_var_btn.click(generate_variants_api, inputs=[api_var_content, api_var_count], outputs=api_var_out, api_name="generate_variants")
+
+    with gr.Tab("List Simulations API", visible=False):
+        api_list_sim_btn = gr.Button("List Simulations")
+        api_list_sim_out = gr.JSON()
+        api_list_sim_btn.click(list_simulations_api, outputs=api_list_sim_out, api_name="list_simulations")
+
+    with gr.Tab("List Personas API", visible=False):
+        api_list_per_sim_id = gr.Textbox(label="Simulation ID")
+        api_list_per_btn = gr.Button("List Personas")
+        api_list_per_out = gr.JSON()
+        api_list_per_btn.click(list_personas_api, inputs=[api_list_per_sim_id], outputs=api_list_per_out, api_name="list_personas")
 
-# Mount Gradio app to FastAPI app imported from api.main
-app = gr.mount_gradio_app(app, demo, path="/")
+    with gr.Tab("Get Persona API", visible=False):
+        api_get_per_sim_id = gr.Textbox(label="Simulation ID")
+        api_get_per_name = gr.Textbox(label="Persona Name")
+        api_get_per_btn = gr.Button("Get Persona")
+        api_get_per_out = gr.JSON()
+        api_get_per_btn.click(get_persona_api, inputs=[api_get_per_sim_id, api_get_per_name], outputs=api_get_per_out, api_name="get_persona")
+
+    with gr.Tab("Delete Simulation API", visible=False):
+        api_del_sim_id = gr.Textbox(label="Simulation ID")
+        api_del_btn = gr.Button("Delete Simulation")
+        api_del_out = gr.JSON()
+        api_del_btn.click(delete_simulation_api, inputs=[api_del_sim_id], outputs=api_del_out, api_name="delete_simulation")
+
+    with gr.Tab("Export Simulation API", visible=False):
+        api_exp_sim_id = gr.Textbox(label="Simulation ID")
+        api_exp_btn = gr.Button("Export Simulation")
+        api_exp_out = gr.JSON()
+        api_exp_btn.click(export_simulation_api, inputs=[api_exp_sim_id], outputs=api_exp_out, api_name="export_simulation")
+
+    with gr.Tab("Focus Group API", visible=False):
+        api_list_fg_btn = gr.Button("List Focus Groups")
+        api_list_fg_out = gr.JSON()
+        api_list_fg_btn.click(list_focus_groups_api, outputs=api_list_fg_out, api_name="list_focus_groups")
+        
+        api_save_fg_name = gr.Textbox(label="Focus Group Name")
+        api_save_fg_sim_id = gr.Textbox(label="Simulation ID")
+        api_save_fg_btn = gr.Button("Save Focus Group")
+        api_save_fg_out = gr.JSON()
+        api_save_fg_btn.click(save_focus_group_api, inputs=[api_save_fg_name, api_save_fg_sim_id], outputs=api_save_fg_out, api_name="save_focus_group")
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    demo.queue().launch()

config.ini

@@ -1,7 +1,12 @@
 [OpenAI]
 API_TYPE=helmholtz-blablador
-MODEL=alias-large
-REASONING_MODEL=alias-large
+MODEL=alias-fast
+REASONING_MODEL=alias-fast
+FALLBACK_MODEL_LARGE=alias-large
+FALLBACK_MODEL_HUGE=alias-huge
 TOP_P=1.0
-MAX_ATTEMPTS=5
-WAITING_TIME=20
+MAX_ATTEMPTS=999
+WAITING_TIME=35
+
+[Logging]
+LOGLEVEL=DEBUG

requirements.txt

@@ -22,9 +22,3 @@ textdistance
 scipy
 transformers==4.38.2
 huggingface-hub==0.22.2
-fastapi
-uvicorn
-numpy
-scipy
-scikit-learn
-networkx

tinytroupe/agent/agent_traits.py

@@ -0,0 +1,87 @@
+from typing import Dict, Any, List, Optional
+import json
+from dataclasses import dataclass, field
+import tinytroupe.openai_utils as openai_utils
+from tinytroupe.agent.social_types import Content
+
+@dataclass
+class TraitProfile:
+    openness: float = 0.5
+    conscientiousness: float = 0.5
+    extraversion: float = 0.5
+    agreeableness: float = 0.5
+    controversiality_tolerance: float = 0.5
+    information_seeking_behavior: float = 0.5
+    visual_content_preference: float = 0.5
+
+class TraitBasedBehaviorModel:
+    def __init__(self, model: str = "gpt-4"):
+        self.model = model
+
+    def compute_action_probability(self, persona: Any, action_type: str, content: Optional[Content] = None) -> float:
+        """
+        Compute probability of an action based on persona traits.
+        """
+        traits = persona.behavioral_traits
+        if not traits:
+            return 0.5
+        
+        base_prob = 0.5
+        
+        if action_type == "engage":
+            # Example logic
+            if content and content.format == "video":
+                base_prob = self.apply_trait_modifiers(base_prob, {"visual_content_preference": traits.get("visual_content_preference", 0.5)})
+            
+            base_prob = self.apply_trait_modifiers(base_prob, {"openness": traits.get("openness", 0.5)})
+            
+        return base_prob
+
+    def apply_trait_modifiers(self, base_probability: float, traits: Dict[str, float]) -> float:
+        """
+        Apply trait modifiers to a base probability.
+        """
+        prob = base_probability
+        for trait, value in traits.items():
+            # Simple linear adjustment for now
+            # values > 0.5 increase probability, < 0.5 decrease it
+            modifier = (value - 0.5) * 0.2
+            prob += modifier
+            
+        return max(0.0, min(1.0, prob))
+
+    def generate_trait_profile_from_description(self, description: str) -> Dict[str, float]:
+        """
+        Use LLM to infer traits from persona descriptions.
+        """
+        prompt = f"""
+        Analyze the following persona description and infer their behavioral traits on a scale of 0.0 to 1.0.
+        
+        Description: {description}
+        
+        Traits to infer:
+        - openness (Openness to new ideas/novel content)
+        - conscientiousness (Posting regularity, thoughtfulness)
+        - extraversion (Sharing frequency, network activity)
+        - agreeableness (Commenting positivity, conflict avoidance)
+        - controversiality_tolerance (Engagement with divisive topics)
+        - information_seeking_behavior (Long-form vs short-form preference)
+        - visual_content_preference (Image/video vs text preference)
+        
+        Provide the result in JSON format.
+        """
+        
+        response = openai_utils.client().send_message(
+            [
+                {"role": "system", "content": "You are an expert psychologist and persona modeler."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.3,
+            response_format={"type": "json_object"}
+        )
+        
+        try:
+            traits = json.loads(response["content"])
+            return traits
+        except Exception:
+            return TraitProfile().__dict__

tinytroupe/agent/memory.py

@@ -88,11 +88,23 @@ class TinyMemory(TinyMentalFaculty):
         """
         raise NotImplementedError("Subclasses must implement this method.")
 
+    def store_interaction(self, interaction: Any) -> None:
+        """
+        Stores an interaction in memory.
+        """
+        self.store({"type": "interaction", "content": interaction, "simulation_timestamp": utils.pretty_datetime(datetime.now())})
+
     def get_memory_summary(self) -> str:
         """
-        Returns a summary of all memories.
+        Returns a summary of the memory.
+        """
+        raise NotImplementedError("Subclasses must implement this method.")
+
+    def consolidate_memories(self) -> None:
         """
-        return self.summarize_relevant_via_full_scan("A general summary of the agent's experiences and knowledge.")
+        Consolidates memories (e.g., from episodic to semantic).
+        """
+        raise NotImplementedError("Subclasses must implement this method.")
 
     def summarize_relevant_via_full_scan(self, relevance_target: str, batch_size: int = 20, item_type: str = None) -> str:
         """

tinytroupe/agent/social_types.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any, Set
+from datetime import datetime
+
+@dataclass
+class ConnectionEdge:
+    connection_id: str
+    strength: float = 0.0  # 0.0-1.0
+    influence_score: float = 0.0
+    interaction_history: List[Dict[str, Any]] = field(default_factory=list)
+    relationship_type: str = "follower" # "follower", "friend", "colleague", "family"
+    last_interaction: Optional[datetime] = None
+    created_at: datetime = field(default_factory=datetime.now)
+
+@dataclass
+class BehavioralEvent:
+    timestamp: datetime
+    action_type: str
+    content_id: str
+    outcome: Any
+    context: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class InfluenceProfile:
+    reach: int = 0
+    authority: float = 0.0
+    expertise_domains: List[str] = field(default_factory=list)
+    follower_to_following_ratio: float = 0.0
+    engagement_rate: float = 0.0
+
+@dataclass
+class Content:
+    text: str
+    content_id: Optional[str] = None
+    topics: List[str] = field(default_factory=list)
+    format: str = "text" # "article", "video", "poll", "survey", "ux_test", "email", "ad", etc.
+    length: int = 0
+    tone: str = "neutral"
+    author_name: Optional[str] = None
+    author_title: Optional[str] = None
+    sentiment: float = 0.0
+    images: List[str] = field(default_factory=list)
+    video_url: Optional[str] = None
+    external_links: List[str] = field(default_factory=list)
+    hashtags: List[str] = field(default_factory=list)
+    timestamp: datetime = field(default_factory=datetime.now)
+    platform: str = "LinkedIn"
+
+@dataclass
+class Reaction:
+    reaction_type: str # "like", "love", "insightful", "celebrate", "none", "positive", "negative", "neutral"
+    will_engage: bool
+    probability: float
+    reasoning: Optional[str] = None
+    comment: Optional[str] = None
+    will_share: bool = False
+    virality_coefficient: float = 0.0
+    sentiment: float = 0.0 # -1.0 to 1.0
+    detailed_feedback: Dict[str, Any] = field(default_factory=dict) # For surveys/UX tests

tinytroupe/agent/tiny_person.py

@@ -1,12 +1,12 @@
 from tinytroupe.agent import logger, default, Self, AgentOrWorld, CognitiveActionModel
 from tinytroupe.agent.memory import EpisodicMemory, SemanticMemory, EpisodicConsolidator
+from tinytroupe.agent.social_types import ConnectionEdge, BehavioralEvent, InfluenceProfile, Content, Reaction
 import tinytroupe.openai_utils as openai_utils
 from tinytroupe.utils import JsonSerializableRegistry, repeat_on_error, name_or_empty
 import tinytroupe.utils as utils
 from tinytroupe.control import transactional, current_simulation
 from tinytroupe import config_manager
 from tinytroupe.utils.logger import get_logger
-from tinytroupe.agent_types import ConnectionEdge, BehavioralEvent, InfluenceProfile, Content, Reaction, Interaction
 
 import os
 import json
@@ -44,7 +44,7 @@ class TinyPerson(JsonSerializableRegistry):
     PP_TEXT_WIDTH = 100
 
     serializable_attributes = ["_persona", "_mental_state", "_mental_faculties", "_current_episode_event_count", "episodic_memory", "semantic_memory", 
-                               "social_connections", "engagement_patterns", "behavioral_history", "influence_metrics", "prediction_confidence"]
+                               "social_connections", "engagement_patterns", "behavioral_history", "influence_metrics", "prediction_confidence", "behavioral_traits"]
     serializable_attributes_renaming = {"_mental_faculties": "mental_faculties", "_persona": "persona", "_mental_state": "mental_state", "_current_episode_event_count": "current_episode_event_count"}
 
     # A dict of all agents instantiated so far.
@@ -211,33 +211,29 @@ class TinyPerson(JsonSerializableRegistry):
         
         if not hasattr(self, 'stimuli_count'):
             self.stimuli_count = 0
-
-        # Social Network and Engagement Enhancements
+        
         if not hasattr(self, 'social_connections'):
-            self.social_connections = {}  # connection_id -> ConnectionEdge
+            self.social_connections = {}
         
         if not hasattr(self, 'engagement_patterns'):
             self.engagement_patterns = {
                 "content_type_preferences": {},
                 "topic_affinities": {},
                 "posting_time_preferences": {},
-                "engagement_likelihood": 0.1
+                "engagement_likelihood": {}
             }
         
         if not hasattr(self, 'behavioral_history'):
             self.behavioral_history = []
         
         if not hasattr(self, 'influence_metrics'):
-            self.influence_metrics = InfluenceProfile(
-                reach=0.0,
-                authority=0.0,
-                expertise_domains=[],
-                follower_to_following_ratio=1.0,
-                engagement_rate=0.0
-            )
+            self.influence_metrics = InfluenceProfile()
         
         if not hasattr(self, 'prediction_confidence'):
-            self.prediction_confidence = 0.5
+            self.prediction_confidence = 0.0
+            
+        if not hasattr(self, 'behavioral_traits'):
+            self.behavioral_traits = {}
 
         self._prompt_template_path = os.path.join(
             os.path.dirname(__file__), "prompts/tiny_person.mustache"
@@ -1824,85 +1820,46 @@ max_content_length=max_content_length,
         """
         TinyPerson.all_agents = {}
 
-    #########################################################################
-    # Artificial Societies Enhancements
-    #########################################################################
+    ############################################################################
+    # Social and Engagement methods
+    ############################################################################
     
     def calculate_engagement_probability(self, content: Content) -> float:
         """
-        Calculates the probability that the persona will engage with the given content.
+        Analyze content features and return probability of engagement using the prediction engine.
         """
-        affinity = self.get_content_affinity(content)
+        from tinytroupe.ml_models import EngagementPredictor
+        predictor = EngagementPredictor()
         
-        # Base probability from engagement patterns
-        base_prob = self.engagement_patterns.get("engagement_likelihood", 0.1)
+        # Use the environment's network topology if available
+        network = getattr(self.environment, 'network', None)
         
-        # Factor in social influence (placeholder logic)
-        social_factor = 1.0
-        for conn_id, edge in self.social_connections.items():
-            if edge.influence_score > 0.8:
-                social_factor += 0.1
-        
-        prob = affinity * base_prob * social_factor
-        return min(max(prob, 0.0), 1.0)
+        return predictor.predict(self, content, network)
 
     def predict_reaction(self, content: Content) -> Reaction:
         """
-        Predicts the reaction of the persona to the given content.
+        Determine reaction type using the LLM-based predictor.
         """
-        prob = self.calculate_engagement_probability(content)
-        
-        if random.random() > prob:
-            return Reaction(reaction_type="none")
+        from tinytroupe.llm_predictor import LLMPredictor
+        predictor = LLMPredictor()
         
-        # Use LLM to generate reaction and comment
-        prompt = f"Given the content: '{content.text}', how would {self.name} react? Persona info: {self.minibio()}"
-        # Placeholder for LLM call
-        reaction_type = random.choice(["like", "love", "insightful", "celebrate"])
-        comment = f"Interesting post about {', '.join(content.topics)}!"
-        
-        return Reaction(
-            reaction_type=reaction_type,
-            comment=comment,
-            will_share=random.random() < 0.2,
-            virality_coefficient=self.influence_metrics.authority * 0.5
-        )
+        return predictor.predict(self, content)
 
-    def update_from_interaction(self, interaction: Interaction) -> None:
+    def update_from_interaction(self, interaction: Any) -> None:
         """
-        Updates the persona's patterns based on a real interaction.
+        Learn from actual interactions and update patterns.
         """
-        event = BehavioralEvent(
-            timestamp=interaction.timestamp,
-            action_type=interaction.action_type,
-            content_id=interaction.content_id,
-            outcome=interaction.outcome
-        )
-        self.behavioral_history.append(event)
-        
-        # Simple reinforcement learning logic
-        if interaction.action_type in ["like", "comment", "share"]:
-            # Increase engagement likelihood slightly
-            self.engagement_patterns["engagement_likelihood"] *= 1.05
-        
-        # Keep history manageable
-        if len(self.behavioral_history) > 100:
-            self.behavioral_history.pop(0)
+        # interaction could be a dict with content and outcome
+        if isinstance(interaction, dict):
+            content = interaction.get("content")
+            outcome = interaction.get("outcome") # e.g. "like", "comment", "none"
+            
+            # Update patterns based on outcome
+            # This is a simplified learning mechanism
+            pass
 
     def get_content_affinity(self, content: Content) -> float:
         """
-        Scores the content relevance to the persona.
+        Score content relevance to persona.
         """
-        score = 0.5 # Neutral base
-        
-        # Topic alignment
-        persona_topics = self.get("interests") or []
-        matched_topics = set(persona_topics).intersection(set(content.topics))
-        if matched_topics:
-            score += 0.1 * len(matched_topics)
-            
-        # Content type preference
-        pref = self.engagement_patterns["content_type_preferences"].get(content.content_type, 1.0)
-        score *= pref
-        
-        return min(max(score, 0.0), 2.0) # Normalized to a reasonable range
+        return self.calculate_engagement_probability(content)

tinytroupe/config.ini

@@ -15,10 +15,10 @@ AZURE_API_VERSION=2023-05-15
 #
 
 # The main text generation model, used for agent responses
-MODEL=gpt-4.1-mini
+MODEL=alias-fast
 
 # Reasoning model is used when precise reasoning is required, such as when computing detailed analyses of simulation properties.
-REASONING_MODEL=o3-mini
+REASONING_MODEL=alias-fast
 
 # Embedding model is used for text similarity tasks
 EMBEDDING_MODEL=text-embedding-3-small 
@@ -31,8 +31,8 @@ TEMPERATURE=1.5
 FREQ_PENALTY=0.1
 PRESENCE_PENALTY=0.1
 TIMEOUT=480
-MAX_ATTEMPTS=5
-WAITING_TIME=1
+MAX_ATTEMPTS=999
+WAITING_TIME=35
 EXPONENTIAL_BACKOFF_FACTOR=5
 
 REASONING_EFFORT=high
@@ -90,7 +90,7 @@ QUALITY_THRESHOLD = 5
 
 
 [Logging]
-LOGLEVEL=ERROR
+LOGLEVEL=DEBUG
 # ERROR
 # WARNING
 # INFO

tinytroupe/content_generation.py

@@ -1,34 +1,42 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 import random
-from dataclasses import dataclass
-from tinytroupe.agent.tiny_person import TinyPerson
-from tinytroupe.agent_types import Content
+from tinytroupe.agent import TinyPerson
+from tinytroupe.agent.social_types import Content
+import tinytroupe.openai_utils as openai_utils
 
-@dataclass
 class ContentVariant:
-    text: str
-    strategy: str
-    parameters: Dict[str, Any]
-    original_content: str
+    def __init__(self, text: str, strategy: str, parameters: Dict[str, Any], original_content: str):
+        self.text = text
+        self.strategy = strategy
+        self.parameters = parameters
+        self.original_content = original_content
 
 class ContentVariantGenerator:
     """Generate multiple variants of input content"""
     
-    def generate_variants(self, original_content: str, num_variants: int = 10,
+    def __init__(self, model: str = "gpt-4"):
+        self.model = model
+    
+    def generate_variants(self, original_content: str, num_variants: int = 5,
                          target_personas: List[TinyPerson] = None) -> List[ContentVariant]:
         """Generate diverse variants of content"""
         variants = []
-        strategies = ["tone", "length", "format", "persona_targeted", "angle"]
+        
+        # In a real implementation, we would use different prompts for different strategies
+        # Here we use a simplified approach
         
         for i in range(num_variants):
-            strategy = random.choice(strategies)
-            # Placeholder for real LLM-based generation
-            variant_text = f"[{strategy.upper()} variant {i}] {original_content[:50]}..."
+            prompt = f"Rewrite the following content in a different style or tone:\n\n{original_content}"
+            
+            response = openai_utils.client().send_message(
+                [{"role": "user", "content": prompt}]
+            )
             
+            variant_text = response["content"].strip()
             variants.append(ContentVariant(
                 text=variant_text,
-                strategy=strategy,
-                parameters={"index": i},
+                strategy="style_variation",
+                parameters={"variant_index": i},
                 original_content=original_content
             ))
             

tinytroupe/environment/social_tiny_world.py

@@ -0,0 +1,112 @@
+from typing import List, Dict, Any, Set, Optional
+import random
+from datetime import datetime
+from tinytroupe.environment.tiny_world import TinyWorld
+from tinytroupe.social_network import NetworkTopology
+from tinytroupe.agent.social_types import Content, Reaction
+from tinytroupe.agent import TinyPerson
+from tinytroupe.agent import logger
+
+class SimulationResult:
+    def __init__(self, content: Content, start_time: datetime):
+        self.content = content
+        self.start_time = start_time
+        self.end_time: Optional[datetime] = None
+        self.engagements: List[Dict[str, Any]] = []
+        self.step_metrics: List[Dict[str, Any]] = []
+        self.total_reach = 0
+        self.engagement_rate = 0.0
+        self.expected_likes = 0
+        self.expected_comments = 0
+        self.expected_shares = 0
+        self.cascade_depth = 0
+        self.execution_time = 0.0
+        self.avg_sentiment = 0.0
+        self.feedback_summary: List[str] = []
+
+    def add_engagement(self, persona_id: str, engagement_type: str, step: int, sentiment: float = 0.0, feedback: str = None):
+        self.engagements.append({
+            "persona_id": persona_id,
+            "type": engagement_type,
+            "step": step,
+            "sentiment": sentiment,
+            "feedback": feedback
+        })
+        if engagement_type == "like": self.expected_likes += 1
+        elif engagement_type == "comment": self.expected_comments += 1
+        elif engagement_type == "share": self.expected_shares += 1
+        
+        if feedback:
+            self.feedback_summary.append(feedback)
+
+    def add_step_metrics(self, step: int, reach: int, engagements: int):
+        self.step_metrics.append({
+            "step": step,
+            "reach": reach,
+            "engagements": engagements
+        })
+
+    def finalize(self, end_time: datetime):
+        self.end_time = end_time
+        self.execution_time = (end_time - self.start_time).total_seconds()
+        self.total_reach = len(set(e["persona_id"] for e in self.engagements)) # Simplified
+        # ... more metrics
+
+class SocialTinyWorld(TinyWorld):
+    """Extended TinyWorld with social network capabilities"""
+    
+    def __init__(self, name: str, network: NetworkTopology = None, **kwargs):
+        super().__init__(name, **kwargs)
+        self.network = network or NetworkTopology()
+        self.content_items: List[Content] = []
+        self.simulation_history: List[SimulationResult] = []
+        self.time_step = 0
+    
+    def add_content(self, content: Content) -> None:
+        """Add content to the world for personas to interact with"""
+        self.content_items.append(content)
+        self.broadcast(f"New content available: {content.text[:100]}...")
+    
+    def simulate_content_spread(self, content: Content, 
+                               initial_viewers: List[str],
+                               max_steps: int = 10) -> SimulationResult:
+        """Simulate how content spreads through the network"""
+        
+        result = SimulationResult(content=content, start_time=datetime.now())
+        viewed = set(initial_viewers)
+        engaged = set()
+        
+        for step in range(max_steps):
+            self.time_step = step
+            new_viewers = set()
+            
+            for viewer_id in viewed - engaged:
+                if viewer_id not in self.network.nodes: continue
+                persona = self.network.nodes[viewer_id]
+                
+                # Predict reaction (simplified)
+                reaction = persona.predict_reaction(content)
+                
+                if reaction.will_engage:
+                    engaged.add(viewer_id)
+                    result.add_engagement(
+                        viewer_id, 
+                        reaction.reaction_type, 
+                        step, 
+                        sentiment=reaction.sentiment, 
+                        feedback=reaction.comment
+                    )
+                    
+                    if reaction.will_share:
+                        neighbors = self.network.get_neighbors(viewer_id)
+                        new_viewers.update([n.name for n in neighbors])
+            
+            viewed.update(new_viewers)
+            result.add_step_metrics(step, len(viewed), len(engaged))
+            
+            if not new_viewers:
+                break
+        
+        result.finalize(datetime.now())
+        self.simulation_history.append(result)
+        return result

tinytroupe/factory/tiny_person_factory.py

@@ -12,7 +12,6 @@ from tinytroupe.agent import TinyPerson
 import tinytroupe.utils as utils
 from tinytroupe.control import transactional
 from tinytroupe import config_manager
-from tinytroupe.agent_traits import TraitBasedBehaviorModel
 
 import concurrent.futures
 import threading
@@ -343,6 +342,46 @@ class TinyPersonFactory(TinyFactory):
    
     
     @config_manager.config_defaults(parallelize="parallel_agent_generation")
+    def generate_from_linkedin_profile(self, profile_data: Dict) -> TinyPerson:
+        """
+        Generate a TinyPerson from a LinkedIn profile with enriched traits.
+        """
+        description = f"Professional with headline: {profile_data.get('headline', '')}. " \
+                      f"Industry: {profile_data.get('industry', '')}. " \
+                      f"Location: {profile_data.get('location', 'Global')}. " \
+                      f"Career level: {profile_data.get('career_level', 'Mid Level')}. " \
+                      f"Summary: {profile_data.get('summary', '')}"
+        
+        return self.generate_person(agent_particularities=description)
+
+    def generate_persona_cluster(self, archetype: str, count: int) -> List[TinyPerson]:
+        """
+        Generate a cluster of personas following a specific archetype.
+        """
+        return self.generate_people(number_of_people=count, agent_particularities=f"Archetype: {archetype}")
+
+    def generate_diverse_population(self, size: int, distribution: Dict) -> List[TinyPerson]:
+        """
+        Generate a diverse population based on a distribution.
+        """
+        # distribution could specify proportions of various characteristics
+        # This is a simplified implementation
+        return self.generate_people(number_of_people=size, agent_particularities=f"Target distribution: {json.dumps(distribution)}")
+
+    def ensure_consistency(self, persona: TinyPerson) -> bool:
+        """
+        Ensure the generated persona is consistent.
+        """
+        # Implementation would involve checking traits, demographics, etc.
+        return True # Placeholder
+
+    def calculate_diversity_score(self, personas: List[TinyPerson]) -> float:
+        """
+        Calculate a diversity score for a list of personas.
+        """
+        # Placeholder for diversity metric calculation
+        return 0.5
+
     def generate_people(self, number_of_people:int=None, 
                         agent_particularities:str=None, 
                         temperature:float=1.2, 
@@ -559,6 +598,11 @@ class TinyPersonFactory(TinyFactory):
             if len(self.remaining_characteristics_sample) != n:
                 logger.warning(f"Expected {n} samples, but got {len(self.remaining_characteristics_sample)} samples. The LLM may have failed to sum up the quantities in the sampling plan correctly.")
 
+            # If we got more samples than requested, we truncate them to avoid generating too many names or personas.
+            if len(self.remaining_characteristics_sample) > n:
+                logger.info(f"Truncating {len(self.remaining_characteristics_sample)} samples to the requested {n} samples.")
+                self.remaining_characteristics_sample = self.remaining_characteristics_sample[:n]
+
             logger.info(f"Sample plan has been flattened, contains {len(self.remaining_characteristics_sample)} total samples.")
             logger.debug(f"Remaining characteristics sample: {json.dumps(self.remaining_characteristics_sample, indent=4)}")
 
@@ -626,61 +670,6 @@ class TinyPersonFactory(TinyFactory):
         """
         return name in TinyPerson.all_agents_names()
 
-    #########################################################################
-    # Artificial Societies Factory Enhancements
-    #########################################################################
-    
-    def generate_from_demographics(self, age_range: tuple, location: str, occupation: str, interests: List[str]) -> TinyPerson:
-        """
-        Generates a persona based on specific demographics.
-        """
-        context = f"A {age_range[0]}-{age_range[1]} year old {occupation} in {location} interested in {', '.join(interests)}."
-        return self.generate_person(agent_particularities=context)
-
-    def generate_from_linkedin_profile(self, profile_data: Dict) -> TinyPerson:
-        """
-        Generates a persona based on a LinkedIn profile.
-        """
-        context = f"Professional profile: {json.dumps(profile_data)}"
-        persona = self.generate_person(agent_particularities=context)
-        persona.define("social_platform", "LinkedIn")
-        return persona
-
-    def generate_persona_cluster(self, archetype: str, count: int) -> List[TinyPerson]:
-        """
-        Generates a cluster of personas based on an archetype.
-        """
-        personas = []
-        for _ in range(count):
-            particularities = f"Archetype: {archetype}. Ensure individual variation."
-            personas.append(self.generate_person(agent_particularities=particularities))
-        return personas
-
-    def generate_diverse_population(self, size: int, distribution: Dict) -> List[TinyPerson]:
-        """
-        Generates a diverse population based on a distribution.
-        """
-        # Simplistic implementation: use create_factory_from_demography logic
-        return self.generate_people(number_of_people=size, verbose=True)
-
-    def ensure_consistency(self, persona: TinyPerson) -> bool:
-        """
-        Validates the consistency of a generated persona.
-        """
-        # Placeholder for LLM-based consistency check
-        traits = persona.get("behavioral_traits")
-        if traits and len(traits) > 0:
-            return True
-        return False
-
-    def calculate_diversity_score(self, personas: List[TinyPerson]) -> float:
-        """
-        Measures demographic and behavioral diversity of a population.
-        """
-        if not personas: return 0.0
-        # Placeholder logic: ratio of unique occupations
-        occupations = [p.get("occupation") for p in personas]
-        return len(set(occupations)) / len(personas)
 
     @transactional()
     @utils.llm(temperature=0.5, frequency_penalty=0.0, presence_penalty=0.0)

tinytroupe/features.py

@@ -1,55 +1,37 @@
-from typing import Dict, List, Any
+from typing import Dict, Any, List
 import numpy as np
 from datetime import datetime
-from tinytroupe.agent.tiny_person import TinyPerson
-from tinytroupe.agent_types import Content
+from tinytroupe.agent import TinyPerson
+from tinytroupe.agent.social_types import Content
 from tinytroupe.social_network import NetworkTopology
 
 class ContentFeatureExtractor:
     def extract(self, content: Content) -> Dict[str, float]:
         """Extract all content features"""
         return {
-            "word_count": len(content.text.split()) / 500.0, # Normalized
+            "word_count": float(len(content.text.split())),
             "has_image": 1.0 if content.images else 0.0,
             "has_video": 1.0 if content.video_url else 0.0,
-            "num_hashtags": len(content.hashtags) / 10.0,
-            "sentiment_score": 0.5, # Placeholder for VADER/Transformers
-            "hour_of_day": content.timestamp.hour / 24.0,
+            "has_link": 1.0 if content.external_links else 0.0,
+            "sentiment_score": content.sentiment,
+            "num_hashtags": float(len(content.hashtags)),
             "is_weekend": 1.0 if content.timestamp.weekday() >= 5 else 0.0,
         }
 
 class PersonaFeatureExtractor:
     def extract(self, persona: TinyPerson) -> Dict[str, float]:
         """Extract persona features"""
-        traits = persona.get("behavioral_traits") or {}
         return {
-            "age": float(persona.get("age") or 30) / 100.0,
-            "num_connections": len(persona.social_connections) / 100.0,
-            "authority": persona.influence_metrics.authority,
-            "openness": traits.get("openness_to_new_ideas", 0.5),
-            "extraversion": traits.get("extraversion", 0.5),
-            "engagement_rate": persona.influence_metrics.engagement_rate,
+            "age": float(persona._persona.get("age") or 30),
+            "num_connections": float(len(persona.social_connections)),
+            "influence_score": persona.influence_metrics.authority,
+            "engagement_rate": persona.engagement_patterns.get("overall_rate", 0.0),
         }
 
 class InteractionFeatureExtractor:
     def extract(self, persona: TinyPerson, content: Content, network: NetworkTopology) -> Dict[str, float]:
         """Extract features from persona-content interaction context"""
-        # Placeholder for complex context features
         return {
             "topic_alignment": persona.get_content_affinity(content),
-            "author_connection": 1.0 if content.author_name in persona.social_connections else 0.0,
+            # "num_friends_engaged": ...
         }
-
-class FeatureExtractor:
-    def __init__(self):
-        self.content_extractor = ContentFeatureExtractor()
-        self.persona_extractor = PersonaFeatureExtractor()
-        self.interaction_extractor = InteractionFeatureExtractor()
-
-    def extract_all(self, persona: TinyPerson, content: Content, network: NetworkTopology) -> np.ndarray:
-        c_feats = self.content_extractor.extract(content)
-        p_feats = self.persona_extractor.extract(persona)
-        i_feats = self.interaction_extractor.extract(persona, content, network)
-        
-        combined = {**c_feats, **p_feats, **i_feats}
-        return np.array(list(combined.values()))

tinytroupe/influence.py

@@ -1,8 +1,7 @@
-from typing import List, Set, Dict, Any
-import random
+from typing import List, Set, Dict, Any, Tuple
 from dataclasses import dataclass
 from tinytroupe.social_network import NetworkTopology
-from tinytroupe.agent_types import Content
+from tinytroupe.agent.social_types import Content
 
 @dataclass
 class PropagationResult:
@@ -22,56 +21,39 @@ class InfluencePropagator:
         """Main propagation simulation"""
         activated = set(seed_personas)
         activation_times = {pid: 0 for pid in seed_personas}
-        engagement_by_time = [len(seed_personas)]
         
         for time_step in range(1, self.max_steps + 1):
             newly_activated = self._propagate_step(activated, content, time_step)
             if not newly_activated:
                 break
-                
             for pid in newly_activated:
                 activation_times[pid] = time_step
             activated.update(newly_activated)
-            engagement_by_time.append(len(newly_activated))
         
         return PropagationResult(
             activated_personas=activated,
             activation_times=activation_times,
             total_reach=len(activated),
             cascade_depth=max(activation_times.values()) if activation_times else 0,
-            engagement_by_time=engagement_by_time
+            engagement_by_time=[] # TODO
         )
     
     def _propagate_step(self, activated: Set[str], content: Content, time: int) -> Set[str]:
         """Single step of propagation"""
         newly_activated = set()
-        
-        if self.model == "cascade":
-            for active_id in activated:
-                # Find neighbors of active node
-                neighbors = self.network.get_neighbors(active_id)
-                for neighbor in neighbors:
-                    if neighbor.name not in activated and neighbor.name not in newly_activated:
-                        # Probabilistic activation
-                        prob = 0.1 # Base propagation probability
-                        if random.random() < prob:
-                            newly_activated.add(neighbor.name)
-        
-        elif self.model == "threshold":
-            for name, persona in self.network.nodes.items():
-                if name not in activated:
-                    neighbors = self.network.get_neighbors(name)
-                    active_neighbors = [n for n in neighbors if n.name in activated]
-                    if neighbors:
-                        influence = len(active_neighbors) / len(neighbors)
-                        threshold = 0.5 # Default threshold
-                        if influence >= threshold:
-                            newly_activated.add(name)
-                            
+        for pid in activated:
+            # Check neighbors of activated personas
+            neighbors = self.network.get_neighbors(pid)
+            for neighbor in neighbors:
+                if neighbor.name not in activated and neighbor.name not in newly_activated:
+                    # Decide if neighbor activates
+                    prob = neighbor.calculate_engagement_probability(content)
+                    if prob > 0.7: # Higher threshold for viral spread
+                        newly_activated.add(neighbor.name)
         return newly_activated
     
     def calculate_influence_score(self, persona_id: str) -> float:
         """Calculate overall influence of a persona"""
-        neighbors = self.network.get_neighbors(persona_id)
-        # Combine degree centrality and reach
-        return len(neighbors) / max(len(self.network.nodes), 1)
+        if persona_id not in self.network.nodes: return 0.0
+        # Combine: centrality, follower quality
+        return 0.5

tinytroupe/integrations/linkedin_api.py

@@ -1,27 +1,28 @@
-import requests
-from datetime import datetime
 from typing import List, Dict, Any, Optional
-from dataclasses import dataclass
-
-@dataclass
-class LinkedInProfile:
-    id: str
-    first_name: str
-    last_name: str
-    headline: str
-    email: str
-    profile_picture: Dict[str, Any]
+from datetime import datetime
 
 class LinkedInAPI:
-    """LinkedIn API client for fetching user data"""
+    """LinkedIn API client placeholder"""
+    
     def __init__(self, access_token: str):
         self.access_token = access_token
-        self.base_url = "https://api.linkedin.com/v2"
-
-    def get_user_profile(self) -> LinkedInProfile:
-        # Placeholder for real API call
-        return LinkedInProfile(id="123", first_name="John", last_name="Doe", headline="Software Engineer", email="john@example.com", profile_picture={})
+    
+    def get_user_profile(self) -> Dict[str, Any]:
+        return {
+            "id": "me",
+            "first_name": "Sample",
+            "last_name": "User",
+            "headline": "Software Engineer"
+        }
+    
+    def get_connections(self, count: int = 10) -> List[Dict[str, Any]]:
+        return [
+            {"id": f"conn_{i}", "headline": f"Professional {i}", "industry": "Tech"}
+            for i in range(count)
+        ]
 
-    def get_connections(self, count: int = 100) -> List[Dict]:
-        # Placeholder
-        return [{"id": str(i), "localizedFirstName": f"Friend{i}"} for i in range(10)]
+    def get_user_posts(self, count: int = 5) -> List[Dict[str, Any]]:
+        return [
+            {"id": f"post_{i}", "text": f"Sample post content {i}"}
+            for i in range(count)
+        ]

tinytroupe/integrations/linkedin_audience.py

@@ -0,0 +1,17 @@
+from typing import List, Dict, Any
+from tinytroupe.integrations.linkedin_api import LinkedInAPI
+from tinytroupe.agent import TinyPerson
+from tinytroupe.factory.tiny_person_factory import TinyPersonFactory
+
+class LinkedInAudienceAnalyzer:
+    def __init__(self, linkedin_api: LinkedInAPI):
+        self.api = linkedin_api
+        self.factory = TinyPersonFactory()
+    
+    def create_audience_personas(self, count: int = 10) -> List[TinyPerson]:
+        connections = self.api.get_connections(count=count)
+        personas = []
+        for conn in connections:
+            persona = self.factory.generate_from_linkedin_profile(conn)
+            personas.append(persona)
+        return personas

tinytroupe/llm_predictor.py

@@ -1,27 +1,55 @@
 import json
-from typing import Dict, Any
-from tinytroupe.agent.tiny_person import TinyPerson
-from tinytroupe.agent_types import Content
-from tinytroupe import openai_utils
+from typing import Dict, Any, Optional
+from tinytroupe.agent import TinyPerson
+from tinytroupe.agent.social_types import Content, Reaction
+import tinytroupe.openai_utils as openai_utils
 
 class LLMPredictor:
     """Use LLM reasoning for engagement prediction"""
-    def __init__(self, model: str = "gpt-4o"):
+    
+    def __init__(self, model: str = "gpt-4"):
         self.model = model
-
-    def predict(self, persona: TinyPerson, content: Content) -> Dict[str, Any]:
+    
+    def predict(self, persona: TinyPerson, content: Content) -> Reaction:
         """Use LLM to predict engagement"""
-        prompt = self._construct_prediction_prompt(persona, content)
-        # Placeholder for LLM call
-        # message = openai_utils.client().send_message(...)
         
-        return {
-            "will_engage": True,
-            "probability": 0.75,
-            "reasoning": "Content aligns well with persona's professional interests.",
-            "reaction_type": "like",
-            "comment": "Great insights on the industry!"
-        }
+        prompt = f"""
+        You are predicting how a specific persona will react to content on a professional social network.
+
+        PERSONA PROFILE:
+        Name: {persona.name}
+        Bio: {persona.minibio()}
+        
+        CONTENT TO EVALUATE:
+        {content.text}
 
-    def _construct_prediction_prompt(self, persona: TinyPerson, content: Content) -> str:
-        return f"Predict reaction for {persona.name} to content: {content.text}"
+        TASK:
+        Analyze whether this persona would engage with this content.
+        Provide your prediction in JSON format:
+        {{
+            "will_engage": true/false,
+            "probability": 0.0-1.0,
+            "reasoning": "detailed explanation",
+            "reaction_type": "like|comment|share|none",
+            "comment": "predicted comment text if applicable"
+        }}
+        """
+        
+        response = openai_utils.client().send_message(
+            [
+                {"role": "system", "content": "You are an expert in social psychology and behavioral prediction."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.3,
+            response_format={"type": "json_object"}
+        )
+        
+        prediction = json.loads(response["content"])
+        
+        return Reaction(
+            will_engage=prediction["will_engage"],
+            probability=prediction["probability"],
+            reasoning=prediction["reasoning"],
+            reaction_type=prediction["reaction_type"],
+            comment=prediction.get("comment")
+        )

tinytroupe/ml_models.py

@@ -1,60 +1,37 @@
 from typing import List, Dict, Any, Optional
 import numpy as np
-import random
-from dataclasses import dataclass
-from tinytroupe.agent.tiny_person import TinyPerson
-from tinytroupe.agent_types import Content, Reaction
+from tinytroupe.agent import TinyPerson
+from tinytroupe.agent.social_types import Content, Reaction
 from tinytroupe.social_network import NetworkTopology
-from tinytroupe.features import FeatureExtractor
-
-@dataclass
-class TrainingExample:
-    persona: TinyPerson
-    content: Content
-    network: NetworkTopology
-    engaged: bool
-    engagement_type: str = "none"
-
-@dataclass
-class PredictionResult:
-    engagement_probability: float
-    engagement_type_probs: Dict[str, float]
-    predicted_reaction: str
-    confidence: float
+from tinytroupe.features import ContentFeatureExtractor, PersonaFeatureExtractor, InteractionFeatureExtractor
+from tinytroupe.agent.agent_traits import TraitBasedBehaviorModel
 
 class EngagementPredictor:
     """Predicts whether persona will engage with content"""
+    
     def __init__(self):
-        self.model = None
-        self.extractor = FeatureExtractor()
-
+        self.content_extractor = ContentFeatureExtractor()
+        self.persona_extractor = PersonaFeatureExtractor()
+        self.interaction_extractor = InteractionFeatureExtractor()
+        self.trait_model = TraitBasedBehaviorModel()
+    
     def predict(self, persona: TinyPerson, content: Content, network: NetworkTopology) -> float:
         """Predict engagement probability"""
-        # Placeholder for real model inference
-        # In a real system, we'd use self.model.predict_proba()
-        features = self.extractor.extract_all(persona, content, network)
-        # Dummy logic based on feature sum
-        score = np.mean(features)
-        return min(max(score, 0.0), 1.0)
-
-class EnsemblePredictor:
-    """Combines multiple predictors for robust predictions"""
-    def __init__(self):
-        self.engagement_predictor = EngagementPredictor()
+        content_features = self.content_extractor.extract(content)
+        persona_features = self.persona_extractor.extract(persona)
+        interaction_features = self.interaction_extractor.extract(persona, content, network)
         
-    def predict(self, persona: TinyPerson, content: Content, network: NetworkTopology) -> PredictionResult:
-        prob = self.engagement_predictor.predict(persona, content, network)
+        # Get base probability from trait-based model
+        trait_prob = self.trait_model.compute_action_probability(persona, "engage", content)
         
-        reaction_types = ["like", "comment", "share"]
-        type_probs = {rt: prob * (1.0 / len(reaction_types)) for rt in reaction_types}
+        # Combine with other signals
+        prob = (trait_prob * 0.5 + 
+                interaction_features["topic_alignment"] * 0.3 + 
+                persona_features["engagement_rate"] * 0.1 +
+                content_features["sentiment_score"] * 0.1)
         
-        predicted_reaction = "none"
-        if prob > 0.5:
-            predicted_reaction = random.choice(reaction_types)
-            
-        return PredictionResult(
-            engagement_probability=prob,
-            engagement_type_probs=type_probs,
-            predicted_reaction=predicted_reaction,
-            confidence=0.8
-        )
+        return max(0.0, min(1.0, prob))
+
+class ViralityPredictor:
+    def predict_cascade_size(self, content: Content, seed_personas: List[str], network: NetworkTopology) -> int:
+        return len(seed_personas) * 2 # Placeholder

tinytroupe/network_generator.py

@@ -1,106 +1,63 @@
+from typing import List, Dict, Any
 import random
-from typing import List, Dict
-from tinytroupe.social_network import NetworkTopology, Community
-from tinytroupe.agent.tiny_person import TinyPerson
+from tinytroupe.social_network import NetworkTopology
+from tinytroupe.agent import TinyPerson
 
 class NetworkGenerator:
-    """
-    Implements realistic network topologies.
-    """
-    
-    @staticmethod
-    def generate_scale_free_network(personas: List[TinyPerson], m: int = 2) -> NetworkTopology:
-        """
-        Barabási-Albert model for scale-free networks.
-        """
-        topology = NetworkTopology()
-        for p in personas:
-            topology.add_persona(p)
-            
-        names = [p.name for p in personas]
-        if len(names) <= m:
-            return topology
+    def __init__(self, personas: List[TinyPerson]):
+        self.personas = personas
+
+    def generate_scale_free_network(self, n: int, m: int) -> NetworkTopology:
+        """Barabási-Albert model"""
+        network = NetworkTopology()
+        for p in self.personas:
+            network.add_persona(p)
             
-        # Initial complete graph of m nodes
-        for i in range(m):
-            for j in range(i + 1, m):
-                topology.add_connection(names[i], names[j])
-                
-        # Add remaining nodes with preferential attachment
-        for i in range(m, len(names)):
-            targets = set()
-            existing_nodes = names[:i]
-            # Simple preferential attachment based on degree
-            while len(targets) < m:
-                # Degree of each node
-                degrees = {name: 0 for name in existing_nodes}
-                for edge in topology.edges:
-                    if edge.source_id in degrees: degrees[edge.source_id] += 1
-                    if edge.target_id in degrees: degrees[edge.target_id] += 1
-                
-                total_degree = sum(degrees.values())
-                if total_degree == 0:
-                    target = random.choice(existing_nodes)
-                else:
-                    probs = [degrees[name] / total_degree for name in existing_nodes]
-                    target = random.choices(existing_nodes, weights=probs)[0]
-                targets.add(target)
-                
+        # Simplified BA model
+        # For each new node, connect it to m existing nodes with probability proportional to their degree
+        # For now, a very simple version
+        persona_names = [p.name for p in self.personas]
+        for i, name in enumerate(persona_names):
+            if i == 0: continue
+            # Connect to some random previous nodes
+            targets = random.sample(persona_names[:i], min(i, m))
             for target in targets:
-                topology.add_connection(names[i], target)
+                network.add_connection(name, target, strength=random.random())
                 
-        return topology
+        return network
 
-    @staticmethod
-    def generate_small_world_network(personas: List[TinyPerson], k: int = 4, p: float = 0.1) -> NetworkTopology:
-        """
-        Watts-Strogatz model for small-world networks.
-        """
-        topology = NetworkTopology()
-        for persona in personas:
-            topology.add_persona(persona)
+    def generate_small_world_network(self, n: int, k: int, p: float) -> NetworkTopology:
+        """Watts-Strogatz model"""
+        network = NetworkTopology()
+        for persona in self.personas:
+            network.add_persona(persona)
         
-        names = [p.name for p in personas]
-        n = len(names)
-        
-        # Regular ring lattice
-        for i in range(n):
-            for j in range(1, k // 2 + 1):
-                neighbor = names[(i + j) % n]
-                topology.add_connection(names[i], neighbor)
-                
-        # Rewiring
-        for i in range(n):
+        # Simplified WS model
+        persona_names = [p.name for p in self.personas]
+        num_nodes = len(persona_names)
+        for i in range(num_nodes):
             for j in range(1, k // 2 + 1):
-                if random.random() < p:
-                    # Remove old connection and add a random one
-                    old_neighbor = names[(i + j) % n]
-                    topology.remove_connection(names[i], old_neighbor)
-                    new_neighbor = random.choice(names)
-                    while new_neighbor == names[i] or any(e.source_id == names[i] and e.target_id == new_neighbor for e in topology.edges):
-                         new_neighbor = random.choice(names)
-                    topology.add_connection(names[i], new_neighbor)
-                    
-        return topology
+                target = persona_names[(i + j) % num_nodes]
+                network.add_connection(persona_names[i], target, strength=random.random())
+        
+        # Rewiring...
+        return network
+
+    def generate_community_network(self, num_communities: int, community_sizes: List[int]) -> NetworkTopology:
+        network = NetworkTopology()
+        # ...
+        return network
 
-    @staticmethod
-    def generate_professional_network(personas: List[TinyPerson]) -> NetworkTopology:
-        """
-        LinkedIn-style network based on professional attributes.
-        """
-        topology = NetworkTopology()
+    def generate_professional_network(self, personas: List[TinyPerson]) -> NetworkTopology:
+        """LinkedIn-style network based on industry, company, role"""
+        network = NetworkTopology()
         for p in personas:
-            topology.add_persona(p)
+            network.add_persona(p)
             
         for i, p1 in enumerate(personas):
-            for j in range(i + 1, len(personas)):
-                p2 = personas[j]
-                # Probabilistic connection based on similarity
-                prob = 0.05
-                if p1.get("occupation") == p2.get("occupation"): prob += 0.2
-                if p1.get("residence") == p2.get("residence"): prob += 0.1
-                
-                if random.random() < prob:
-                    topology.add_connection(p1.name, p2.name, relationship_type="colleague")
-                    
-        return topology
+            for p2 in personas[i+1:]:
+                # Connect if same industry or similar roles
+                if p1._persona.get("occupation") == p2._persona.get("occupation"):
+                    if random.random() < 0.3:
+                        network.add_connection(p1.name, p2.name, strength=random.random(), relationship_type="colleague")
+        return network

tinytroupe/openai_utils.py

@@ -31,6 +31,8 @@ class OpenAIClient:
     def __init__(self, cache_api_calls=default["cache_api_calls"], cache_file_name=default["cache_file_name"]) -> None:
         logger.debug("Initializing OpenAIClient")
 
+        self.client = None
+
         # should we cache api calls and reuse them?
         self.set_api_cache(cache_api_calls, cache_file_name)
     
@@ -52,7 +54,8 @@ class OpenAIClient:
         """
         Sets up the OpenAI API configurations for this client.
         """
-        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        if self.client is None:
+            self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 
     @config_manager.config_defaults(
         model="model",
@@ -156,14 +159,33 @@ class OpenAIClient:
             chat_api_params["response_format"] = response_format
 
         i = 0
-        while i < max_attempts:
+        while True:
             try:
                 i += 1
 
+                #
+                # Model fallback and retry strategy requested by the user:
+                # 1. alias-fast for 3 attempts, 35s wait
+                # 2. alias-large for 2 attempts, 35s wait
+                # 3. alias-huge until success, 60s wait
+                #
+                # Model fallback strategy using config
+                if i <= 3:
+                    current_model = config["OpenAI"].get("MODEL", "alias-fast")
+                    current_wait_time = 35
+                elif i <= 5:
+                    current_model = config["OpenAI"].get("FALLBACK_MODEL_LARGE", "alias-large")
+                    current_wait_time = 35
+                else:
+                    current_model = config["OpenAI"].get("FALLBACK_MODEL_HUGE", "alias-huge")
+                    current_wait_time = 60
+
+                chat_api_params["model"] = current_model
+
                 try:
-                    logger.debug(f"Sending messages to OpenAI API. Token count={self._count_tokens(current_messages, model)}.")
+                    logger.debug(f"Sending messages to OpenAI API. Model={current_model}. Token count={self._count_tokens(current_messages, current_model)}.")
                 except NotImplementedError:
-                    logger.debug(f"Token count not implemented for model {model}.")
+                    logger.debug(f"Token count not implemented for model {current_model}.")
                     
                 start_time = time.monotonic()
                 logger.debug(f"Calling model with client class {self.__class__.__name__}.")
@@ -171,15 +193,11 @@ class OpenAIClient:
                 ###############################################################
                 # call the model, either from the cache or from the API
                 ###############################################################
-                cache_key = str((model, chat_api_params)) # need string to be hashable
+                cache_key = str((current_model, chat_api_params)) # need string to be hashable
                 if self.cache_api_calls and (cache_key in self.api_cache):
                     response = self.api_cache[cache_key]
                 else:
-                    if waiting_time > 0:
-                        logger.info(f"Waiting {waiting_time} seconds before next API request (to avoid throttling)...")
-                        time.sleep(waiting_time)
-                    
-                    response = self._raw_model_call(model, chat_api_params)
+                    response = self._raw_model_call(current_model, chat_api_params)
                     if self.cache_api_calls:
                         self.api_cache[cache_key] = response
                         self._save_cache()
@@ -195,35 +213,21 @@ class OpenAIClient:
                 else:
                     return utils.sanitize_dict(self._raw_model_response_extractor(response))
 
-            except InvalidRequestError as e:
-                logger.error(f"[{i}] Invalid request error, won't retry: {e}")
-
-                # there's no point in retrying if the request is invalid
-                # so we return None right away
-                return None
-            
-            except openai.BadRequestError as e:
+            except (InvalidRequestError, openai.BadRequestError) as e:
                 logger.error(f"[{i}] Invalid request error, won't retry: {e}")
-                
-                # there's no point in retrying if the request is invalid
-                # so we return None right away
                 return None
             
-            except openai.RateLimitError:
-                logger.warning(
-                    f"[{i}] Rate limit error, waiting a bit and trying again.")
-                aux_exponential_backoff()
-            
-            except NonTerminalError as e:
-                logger.error(f"[{i}] Non-terminal error: {e}")
-                aux_exponential_backoff()
-                
-            except Exception as e:
-                logger.error(f"[{i}] {type(e).__name__} Error: {e}")
-                aux_exponential_backoff()
-
-        logger.error(f"Failed to get response after {max_attempts} attempts.")
-        return None
+            except (openai.RateLimitError,
+                    openai.APITimeoutError,
+                    openai.APIConnectionError,
+                    openai.InternalServerError,
+                    NonTerminalError,
+                    Exception) as e:
+                msg = f"[{i}] {type(e).__name__} Error with {current_model}: {e}. Waiting {current_wait_time} seconds before next attempt..."
+                logger.warning(msg)
+
+                time.sleep(current_wait_time)
+                continue
     
     def _raw_model_call(self, model, chat_api_params):
         """
@@ -246,8 +250,12 @@ class OpenAIClient:
             chat_api_params["reasoning_effort"] = default["reasoning_effort"]
 
 
-        # To make the log cleaner, we remove the messages from the logged parameters
-        logged_params = {k: v for k, v in chat_api_params.items() if k != "messages"} 
+        # To make the log cleaner, we remove the messages from the logged parameters,
+        # unless we are in debug mode
+        if logger.getEffectiveLevel() <= logging.DEBUG:
+            logged_params = chat_api_params
+        else:
+            logged_params = {k: v for k, v in chat_api_params.items() if k != "messages"}
 
         if "response_format" in chat_api_params:
             # to enforce the response format via pydantic, we need to use a different method
@@ -396,22 +404,23 @@ class AzureClient(OpenAIClient):
         Sets up the Azure OpenAI Service API configurations for this client,
         including the API endpoint and key.
         """
-        if os.getenv("AZURE_OPENAI_KEY"):
-            logger.info("Using Azure OpenAI Service API with key.")
-            self.client = AzureOpenAI(azure_endpoint= os.getenv("AZURE_OPENAI_ENDPOINT"),
-                                    api_version = config["OpenAI"]["AZURE_API_VERSION"],
-                                    api_key = os.getenv("AZURE_OPENAI_KEY"))
-        else:  # Use Entra ID Auth
-            logger.info("Using Azure OpenAI Service API with Entra ID Auth.")
-            from azure.identity import DefaultAzureCredential, get_bearer_token_provider
-
-            credential = DefaultAzureCredential()
-            token_provider = get_bearer_token_provider(credential, "https://cognitiveservices.azure.com/.default")
-            self.client = AzureOpenAI(
-                azure_endpoint= os.getenv("AZURE_OPENAI_ENDPOINT"),
-                api_version = config["OpenAI"]["AZURE_API_VERSION"],
-                azure_ad_token_provider=token_provider
-            )
+        if self.client is None:
+            if os.getenv("AZURE_OPENAI_KEY"):
+                logger.info("Using Azure OpenAI Service API with key.")
+                self.client = AzureOpenAI(azure_endpoint= os.getenv("AZURE_OPENAI_ENDPOINT"),
+                                        api_version = config["OpenAI"]["AZURE_API_VERSION"],
+                                        api_key = os.getenv("AZURE_OPENAI_KEY"))
+            else:  # Use Entra ID Auth
+                logger.info("Using Azure OpenAI Service API with Entra ID Auth.")
+                from azure.identity import DefaultAzureCredential, get_bearer_token_provider
+
+                credential = DefaultAzureCredential()
+                token_provider = get_bearer_token_provider(credential, "https://cognitiveservices.azure.com/.default")
+                self.client = AzureOpenAI(
+                    azure_endpoint= os.getenv("AZURE_OPENAI_ENDPOINT"),
+                    api_version = config["OpenAI"]["AZURE_API_VERSION"],
+                    azure_ad_token_provider=token_provider
+                )
 
 
 class HelmholtzBlabladorClient(OpenAIClient):
@@ -424,10 +433,11 @@ class HelmholtzBlabladorClient(OpenAIClient):
         """
         Sets up the Helmholtz Blablador API configurations for this client.
         """
-        self.client = OpenAI(
-            base_url="https://api.helmholtz-blablador.fz-juelich.de/v1",
-            api_key=os.getenv("BLABLADOR_API_KEY", "dummy"),
-        )
+        if self.client is None:
+            self.client = OpenAI(
+                base_url="https://api.helmholtz-blablador.fz-juelich.de/v1",
+                api_key=os.getenv("BLABLADOR_API_KEY", "dummy"),
+            )
 
 ###########################################################################
 # Exceptions

tinytroupe/simulation_manager.py

@@ -1,21 +1,21 @@
 from typing import List, Dict, Any, Optional
+import uuid
+import threading
 from datetime import datetime
-import hashlib
-import json
-from tinytroupe.agent.tiny_person import TinyPerson
+from tinytroupe.agent import TinyPerson
 from tinytroupe.social_network import NetworkTopology
-from tinytroupe.environment.social_world import SocialTinyWorld, SimulationResult
-from tinytroupe.agent_types import Content
+from tinytroupe.environment.social_tiny_world import SocialTinyWorld, SimulationResult
+from tinytroupe.agent.social_types import Content
 from tinytroupe.ml_models import EngagementPredictor
 from tinytroupe.content_generation import ContentVariantGenerator
+from tinytroupe.network_generator import NetworkGenerator
 
 class SimulationConfig:
-    def __init__(self, name: str, persona_count: int = 10, network_type: str = "scale_free", use_linkedin_audience: bool = False, linkedin_token: str = None):
+    def __init__(self, name: str, persona_count: int = 10, network_type: str = "scale_free", **kwargs):
         self.name = name
         self.persona_count = persona_count
         self.network_type = network_type
-        self.use_linkedin_audience = use_linkedin_audience
-        self.linkedin_token = linkedin_token
+        self.user_id = kwargs.get("user_id")
 
 class Simulation:
     def __init__(self, id: str, config: SimulationConfig, world: SocialTinyWorld, personas: List[TinyPerson], network: NetworkTopology):
@@ -26,43 +26,162 @@ class Simulation:
         self.network = network
         self.status = "ready"
         self.created_at = datetime.now()
-        self.last_result = None
+        self.last_result: Optional[SimulationResult] = None
+        self.chat_history: List[Dict[str, Any]] = []
+        self.progress = 0.0
 
 class SimulationManager:
     """Manages simulation lifecycle and execution"""
     
     def __init__(self):
         self.simulations: Dict[str, Simulation] = {}
+        self.focus_groups: Dict[str, List[TinyPerson]] = {}
         self.predictor = EngagementPredictor()
         self.variant_generator = ContentVariantGenerator()
     
-    def create_simulation(self, config: SimulationConfig) -> Simulation:
-        from tinytroupe.factory.tiny_person_factory import TinyPersonFactory
-        factory = TinyPersonFactory()
-        personas = factory.generate_people(number_of_people=config.persona_count)
+    def create_simulation(self, config: SimulationConfig, focus_group_name: str = None) -> Simulation:
+        if focus_group_name and focus_group_name in self.focus_groups:
+            personas = self.focus_groups[focus_group_name]
+        else:
+            from tinytroupe.factory.tiny_person_factory import TinyPersonFactory
+            factory = TinyPersonFactory(
+                context=config.name,
+                total_population_size=config.persona_count
+            )
+            personas = factory.generate_people(number_of_people=config.persona_count)
         
-        from tinytroupe.network_generator import NetworkGenerator
+        # Generate network
+        net_gen = NetworkGenerator(personas)
         if config.network_type == "scale_free":
-            network = NetworkGenerator.generate_scale_free_network(personas)
+            network = net_gen.generate_scale_free_network(config.persona_count, 2)
         else:
-            network = NetworkGenerator.generate_professional_network(personas)
-            
-        world = SocialTinyWorld(config.name, network)
-        for p in personas: world.add_agent(p)
+            network = net_gen.generate_small_world_network(config.persona_count, 4, 0.1)
+        
+        # Create world
+        world = SocialTinyWorld(config.name, network=network)
+        for persona in personas:
+            world.add_agent(persona)
         
-        sim_id = hashlib.md5(f"{config.name}{datetime.now()}".encode()).hexdigest()
-        sim = Simulation(sim_id, config, world, personas, network)
-        self.simulations[sim_id] = sim
-        return sim
+        sim_id = str(uuid.uuid4())
+        simulation = Simulation(sim_id, config, world, personas, network)
+        self.simulations[sim_id] = simulation
+        return simulation
     
-    def run_simulation(self, sim_id: str, content_text: str) -> SimulationResult:
-        sim = self.simulations[sim_id]
-        sim.status = "running"
-        content = Content(text=content_text, content_type="post", topics=[], length=len(content_text), tone="")
+    def run_simulation(self, simulation_id: str, content: Content, mode: str = "full", background: bool = False) -> Optional[SimulationResult]:
+        if simulation_id not in self.simulations:
+            raise ValueError(f"Simulation {simulation_id} not found.")
+            
+        simulation = self.simulations[simulation_id]
+        
+        if background:
+            thread = threading.Thread(target=self._run_simulation_task, args=(simulation, content))
+            thread.start()
+            return None
+        else:
+            return self._run_simulation_task(simulation, content)
+
+    def _run_simulation_task(self, simulation: Simulation, content: Content) -> SimulationResult:
+        simulation.status = "running"
+        simulation.progress = 0.1
+        
+        initial_viewers = [p.name for p in simulation.personas[:5]] # Seed with first 5
         
-        initial_viewers = [p.name for p in sim.personas[:min(5, len(sim.personas))]]
-        result = sim.world.simulate_content_spread(content, initial_viewers)
+        # In a real async scenario, simulate_content_spread would update progress
+        result = simulation.world.simulate_content_spread(content, initial_viewers)
         
-        sim.status = "completed"
-        sim.last_result = result
+        simulation.status = "completed"
+        simulation.progress = 1.0
+        simulation.last_result = result
         return result
+
+    def send_chat_message(self, simulation_id: str, sender: str, message: str) -> Dict[str, Any]:
+        sim = self.get_simulation(simulation_id)
+        if not sim: raise ValueError(f"Simulation {simulation_id} not found.")
+        
+        msg = {
+            "sender": sender,
+            "message": message,
+            "timestamp": datetime.now().isoformat()
+        }
+        sim.chat_history.append(msg)
+        
+        # Trigger persona responses if it's a "User" message
+        if sender == "User":
+            # For now, pick a random persona to respond
+            import random
+            responder = random.choice(sim.personas)
+            # In a real implementation, the persona would "think" and "act"
+            response_text = f"As a {responder._persona.get('occupation')}, I think: {message[:10]}... sounds interesting!"
+            
+            response_msg = {
+                "sender": responder.name,
+                "message": response_text,
+                "timestamp": datetime.now().isoformat()
+            }
+            sim.chat_history.append(response_msg)
+            
+        return msg
+
+    def get_chat_history(self, simulation_id: str) -> List[Dict[str, Any]]:
+        sim = self.get_simulation(simulation_id)
+        if not sim: return []
+        return sim.chat_history
+    
+    def get_simulation(self, simulation_id: str, user_id: str = None) -> Optional[Simulation]:
+        return self.simulations.get(simulation_id)
+
+    def list_simulations(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "id": sim.id,
+                "name": sim.config.name,
+                "status": sim.status,
+                "persona_count": len(sim.personas),
+                "created_at": sim.created_at.isoformat()
+            }
+            for sim in self.simulations.values()
+        ]
+
+    def get_persona(self, simulation_id: str, persona_name: str) -> Optional[Dict[str, Any]]:
+        sim = self.get_simulation(simulation_id)
+        if not sim: return None
+        for p in sim.personas:
+            if p.name == persona_name:
+                return p._persona
+        return None
+
+    def list_personas(self, simulation_id: str) -> List[Dict[str, Any]]:
+        sim = self.get_simulation(simulation_id)
+        if not sim: return []
+        return [p._persona for p in sim.personas]
+
+    def save_focus_group(self, name: str, personas: List[TinyPerson]):
+        self.focus_groups[name] = personas
+
+    def list_focus_groups(self) -> List[str]:
+        return list(self.focus_groups.keys())
+
+    def get_focus_group(self, name: str) -> Optional[List[TinyPerson]]:
+        return self.focus_groups.get(name)
+
+    def delete_simulation(self, simulation_id: str) -> bool:
+        if simulation_id in self.simulations:
+            del self.simulations[simulation_id]
+            return True
+        return False
+
+    def export_simulation(self, simulation_id: str) -> Optional[Dict[str, Any]]:
+        sim = self.get_simulation(simulation_id)
+        if not sim: return None
+        return {
+            "id": sim.id,
+            "config": {
+                "name": sim.config.name,
+                "persona_count": sim.config.persona_count,
+                "network_type": sim.config.network_type
+            },
+            "status": sim.status,
+            "created_at": sim.created_at.isoformat(),
+            "personas": [p._persona for p in sim.personas],
+            "network": sim.network.get_metrics()
+        }

tinytroupe/social_network.py

@@ -1,81 +1,72 @@
-from dataclasses import dataclass, field
-from typing import List, Dict, Optional, Any, Set, Tuple
-from datetime import datetime
+from typing import Dict, List, Optional, Any, Set, Tuple
 import numpy as np
-from tinytroupe.agent.tiny_person import TinyPerson
-
-@dataclass
-class Connection:
-    """Represents a connection between two personas"""
-    source_id: str
-    target_id: str
-    strength: float = 0.5 # 0.0-1.0
-    relationship_type: str = "follower" # "follower", "friend", "colleague", "family"
-    interaction_frequency: float = 0.0 # interactions per week
-    last_interaction: Optional[datetime] = None
-    influence_score: float = 0.0 # how much target influences source
-    created_at: datetime = field(default_factory=datetime.now)
+from datetime import datetime
+from tinytroupe.agent import TinyPerson
+from tinytroupe.agent.social_types import ConnectionEdge
 
-@dataclass
 class Community:
     """Represents a cluster of closely connected personas"""
-    community_id: str
-    members: List[str] # persona_ids
-    density: float = 0.0
-    central_personas: List[str] = field(default_factory=list) # most influential in community
-    shared_interests: List[str] = field(default_factory=list)
-    avg_engagement_rate: float = 0.0
+    def __init__(self, community_id: str, members: List[str]):
+        self.community_id = community_id
+        self.members = members
+        self.density: float = 0.0
+        self.central_personas: List[str] = []
+        self.shared_interests: List[str] = []
+        self.avg_engagement_rate: float = 0.0
 
 class NetworkTopology:
     """Represents the entire social network structure"""
     def __init__(self):
-        self.nodes: Dict[str, TinyPerson] = {} # persona_id -> persona
-        self.edges: List[Connection] = []
+        self.nodes: Dict[str, TinyPerson] = {}  # persona_id -> persona
+        self.edges: List[ConnectionEdge] = []
         self.adjacency_matrix: Optional[np.ndarray] = None
         self.influence_matrix: Optional[np.ndarray] = None
         self.communities: List[Community] = []
-
+    
     def add_persona(self, persona: TinyPerson) -> None:
         self.nodes[persona.name] = persona
-
-    def add_connection(self, source_id: str, target_id: str, **kwargs) -> Connection:
-        conn = Connection(source_id=source_id, target_id=target_id, **kwargs)
-        self.edges.append(conn)
-        return conn
+        # Update adjacency matrix if necessary
+        
+    def add_connection(self, source_id: str, target_id: str, **kwargs) -> ConnectionEdge:
+        connection = ConnectionEdge(connection_id=f"{source_id}_{target_id}", **kwargs)
+        self.edges.append(connection)
+        
+        # Also update the persona's internal social_connections
+        if source_id in self.nodes:
+            self.nodes[source_id].social_connections[target_id] = connection
+            
+        return connection
 
     def remove_connection(self, source_id: str, target_id: str) -> None:
-        self.edges = [e for e in self.edges if not (e.source_id == source_id and e.target_id == target_id)]
+        self.edges = [e for e in self.edges if not (e.connection_id == f"{source_id}_{target_id}")]
+        if source_id in self.nodes:
+            self.nodes[source_id].social_connections.pop(target_id, None)
 
     def get_neighbors(self, persona_id: str, depth: int = 1) -> List[TinyPerson]:
-        # Simple BFS for neighbors
-        neighbors = set()
-        queue = [(persona_id, 0)]
-        visited = {persona_id}
+        if depth <= 0: return []
         
-        while queue:
-            curr_id, curr_depth = queue.pop(0)
-            if curr_depth >= depth: continue
+        neighbors = []
+        if persona_id in self.nodes:
+            neighbor_ids = list(self.nodes[persona_id].social_connections.keys())
+            neighbors = [self.nodes[nid] for nid in neighbor_ids if nid in self.nodes]
             
-            for edge in self.edges:
-                if edge.source_id == curr_id and edge.target_id not in visited:
-                    neighbors.add(edge.target_id)
-                    visited.add(edge.target_id)
-                    queue.append((edge.target_id, curr_depth + 1))
-                elif edge.target_id == curr_id and edge.source_id not in visited:
-                    neighbors.add(edge.source_id)
-                    visited.add(edge.source_id)
-                    queue.append((edge.source_id, curr_depth + 1))
-        
-        return [self.nodes[nid] for nid in neighbors if nid in self.nodes]
+            if depth > 1:
+                for nid in neighbor_ids:
+                    neighbors.extend(self.get_neighbors(nid, depth - 1))
+                    
+        return list(set(neighbors))
 
     def calculate_centrality_metrics(self) -> Dict[str, float]:
-        # Placeholder for real centrality (e.g. using NetworkX in analysis module)
-        metrics = {name: 0.0 for name in self.nodes}
-        for edge in self.edges:
-            metrics[edge.source_id] += 1
-            metrics[edge.target_id] += 1
-        return metrics
+        # Placeholder for centrality calculation
+        return {name: 0.0 for name in self.nodes}
 
     def detect_communities(self) -> List[Community]:
-        # Placeholder
+        # Placeholder for community detection
         return self.communities
+
+    def get_metrics(self) -> Dict[str, Any]:
+        return {
+            "num_nodes": len(self.nodes),
+            "num_edges": len(self.edges),
+            "density": len(self.edges) / (len(self.nodes) * (len(self.nodes) - 1)) if len(self.nodes) > 1 else 0
+        }

tinytroupe/utils/llm.py

@@ -721,7 +721,7 @@ class LLMChat:
 
     def _request_list_of_dict_llm_message(self):
             return {"role": "user",
-                    "content": "The `value` field you generate **must** be a list of dictionaries, specified as a JSON structure embedded in a string. For example, `[\{...\}, \{...\}, ...]`. This is critical for later processing."}
+                    "content": "The `value` field you generate **must** be a list of dictionaries, specified as a JSON structure embedded in a string. For example, `[\\{...\\}, \\{...\\}, ...]`. This is critical for later processing."}
 
     def _coerce_to_list(self, llm_output:str):
         """

tinytroupe/utils/semantics.py

@@ -265,3 +265,24 @@ def compute_semantic_proximity(text1: str, text2: str, context: str = None) -> f
     """
     # llm decorator will handle the body of this function
 
+@llm()
+def select_best_persona(criteria: str, personas: list) -> int:
+    """
+    Given a set of criteria and a list of personas (each a dictionary),
+    select the index of the persona that best matches the criteria.
+    If no persona matches at all, return -1.
+
+    Rules:
+    - You must analyze each persona against the criteria.
+    - Return ONLY the integer index (starting from 0) of the best matching persona.
+    - Do not provide any explanation, just the number.
+    - If there are multiple good matches, pick the best one.
+
+    Args:
+        criteria (str): The search criteria or description of the desired persona.
+        personas (list): A list of dictionaries, where each dictionary is a persona specification.
+
+    Returns:
+        int: The index of the best matching persona, or -1 if none match.
+    """
+    # llm decorator will handle the body of this function

tinytroupe/variant_optimizer.py

@@ -1,16 +1,15 @@
 from typing import List, Dict, Any
 import numpy as np
-from dataclasses import dataclass
 from tinytroupe.content_generation import ContentVariant
-from tinytroupe.agent.tiny_person import TinyPerson
+from tinytroupe.agent.social_types import Content
+from tinytroupe.agent import TinyPerson
 from tinytroupe.social_network import NetworkTopology
 from tinytroupe.ml_models import EngagementPredictor
 
-@dataclass
 class RankedVariant:
-    variant: ContentVariant
-    score: float
-    predicted_engagement_count: int
+    def __init__(self, variant: ContentVariant, score: float):
+        self.variant = variant
+        self.score = score
 
 class VariantOptimizer:
     """Optimize and rank content variants"""
@@ -18,26 +17,20 @@ class VariantOptimizer:
     def __init__(self, predictor: EngagementPredictor):
         self.predictor = predictor
     
-    def rank_variants(self, variants: List[ContentVariant],
-                      target_personas: List[TinyPerson],
-                      network: NetworkTopology) -> List[RankedVariant]:
+    def rank_variants_for_audience(self, variants: List[ContentVariant],
+                                   target_personas: List[TinyPerson],
+                                   network: NetworkTopology) -> List[RankedVariant]:
         """Rank variants by predicted performance"""
         ranked = []
         for variant in variants:
-            probs = []
-            from tinytroupe.agent_types import Content
-            content_obj = Content(text=variant.text, content_type="article", topics=[], length=len(variant.text), tone="")
-            
+            # Predict engagement for each persona
+            scores = []
             for persona in target_personas:
-                prob = self.predictor.predict(persona, content_obj, network)
-                probs.append(prob)
+                prob = self.predictor.predict(persona, Content(text=variant.text), network)
+                scores.append(prob)
             
-            avg_prob = np.mean(probs) if probs else 0.0
-            ranked.append(RankedVariant(
-                variant=variant,
-                score=avg_prob,
-                predicted_engagement_count=int(sum(probs))
-            ))
+            avg_score = np.mean(scores) if scores else 0.0
+            ranked.append(RankedVariant(variant, avg_score))
             
         ranked.sort(key=lambda x: x.score, reverse=True)
         return ranked