Agents

from langgraph.prebuilt import create_react_agent
from langgraph.checkpoint.memory import MemorySaver

# Create ReAct agent
memory = MemorySaver()
agent = create_react_agent(
    llm=llm,                    # Language model (Claude, GPT, etc.)
    tools=tools,                # Available tools/actions
    checkpointer=memory,        # State persistence
    state_modifier=personality, # Agent personality/instructions
)

async def run_chat_mode(agent_executor, config, runnable_config):
    """Run the agent interactively based on user input."""
    print_system("Starting chat mode... Type 'exit' to end.")
    
    while True:
        user_input = input(f"{Colors.BLUE}{Colors.BOLD}User: {Colors.ENDC}")
        
        if user_input.lower() == "exit":
            break
        
        async for chunk in agent_executor.astream(
            {"messages": [HumanMessage(content=user_input)]},
            runnable_config
        ):
            if "agent" in chunk:
                response = chunk["agent"]["messages"][0].content
                print_ai(format_ai_message_content(response))
            elif "tools" in chunk:
                print_system(chunk["tools"]["messages"][0].content)

async def run_twitter_automation(agent_executor, config, runnable_config):
    """Run the agent autonomously with specified intervals."""
    print_system(f"Starting autonomous mode as {config['character']['name']}...")
    twitter_state.load()
    
    while True:
        # Check if enough time has passed since last check
        if not twitter_state.can_check_mentions():
            wait_time = MENTION_CHECK_INTERVAL - \
                (datetime.now() - twitter_state.last_check_time).total_seconds()
            if wait_time > 0:
                await asyncio.sleep(wait_time)
                continue
        
        # Update check time
        twitter_state.last_check_time = datetime.now()
        twitter_state.save()
        
        # Select KOLs for interaction
        selected_kols = random.sample(config['character']['kol_list'], NUM_KOLS)
        
        # Create autonomous task prompt
        thought = f"""
        Task 1: Query podcast knowledge base and recent tweets
        Task 2: Check for and reply to new Twitter mentions
        Task 3: Interact with KOLs
        """
        
        # Execute autonomous workflow
        async for chunk in agent_executor.astream(
            {"messages": [HumanMessage(content=thought)]},
            runnable_config
        ):
            # Process results...
        
        # Wait before next cycle
        await asyncio.sleep(MENTION_CHECK_INTERVAL)

MENTION_CHECK_INTERVAL = 1800  # 30 minutes
MAX_MENTIONS_PER_INTERVAL = 10

from openai_voice_react_agent import OpenAIVoiceReactAgent

# Create voice agent
agent = OpenAIVoiceReactAgent(
    model="gpt-4o-realtime-preview",
    tools=TOOLS,
    instructions=full_instructions,
    voice="verse"  # Options: alloy, ash, ballad, coral, echo, sage, shimmer, verse
)

# WebSocket endpoint for voice streaming
@app.websocket_route("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    
    # Stream voice input/output
    async for message in websocket.iter_text():
        # Process voice input and stream response
        await agent.process_voice(message, websocket)

runnable_config = RunnableConfig(
    recursion_limit=200,  # Maximum ReAct iterations
    configurable={
        "thread_id": f"{character['name']} Agent",
        "langgraph_checkpoint_ns": "chat_mode",
        "langgraph_checkpoint_id": config["configurable"]["langgraph_checkpoint_id"]
    }
)

config = {
    "configurable": {
        "thread_id": f"{character['name']} Agent",
        "character": character["name"],
        "recursion_limit": 100,
        "checkpoint_id": checkpoint_id,
    },
    "character": {
        "name": character["name"],
        "bio": character.get("bio", []),
        "lore": character.get("lore", []),
        "knowledge": character.get("knowledge", []),
        "style": character.get("style", {}),
        "messageExamples": character.get("messageExamples", []),
        "postExamples": character.get("postExamples", []),
        "kol_list": character.get("kol_list", []),
        "accountid": character.get("accountid")
    }
}

class TwitterState:
    def __init__(self):
        self.replied_tweets = set()
        self.reposted_tweets = set()
        self.last_mention_id = None
        self.last_check_time = None
    
    def has_replied_to(self, tweet_id: str) -> bool:
        """Check if we've already replied to this tweet."""
        return tweet_id in self.replied_tweets
    
    def add_replied_tweet(self, tweet_id: str) -> str:
        """Mark a tweet as replied to."""
        self.replied_tweets.add(tweet_id)
        self.save()
        return f"Added tweet {tweet_id} to replied database"

# Twitter Knowledge Base
knowledge_base = TweetKnowledgeBase()
await update_knowledge_base(
    twitter_client=twitter_client,
    knowledge_base=knowledge_base,
    kol_list=config['character']['kol_list']
)

# Podcast Knowledge Base
podcast_knowledge_base = PodcastKnowledgeBase()
podcast_knowledge_base.process_all_json_files()

# Add to tools
tools.append(Tool(
    name="query_twitter_knowledge_base",
    func=lambda query: knowledge_base.query_knowledge_base(query),
    description="Query the Twitter knowledge base for relevant tweets"
))

# Stream agent responses
async for chunk in agent_executor.astream(
    {"messages": [HumanMessage(content=user_input)]},
    runnable_config
):
    if "agent" in chunk:
        # Agent reasoning or final response
        response = chunk["agent"]["messages"][0].content
        print_ai(format_ai_message_content(response))
    
    elif "tools" in chunk:
        # Tool execution results
        tool_result = chunk["tools"]["messages"][0].content
        print_system(tool_result)

try:
    async for chunk in agent_executor.astream(
        {"messages": [HumanMessage(content=thought)]},
        runnable_config
    ):
        # Process chunks
        
except KeyboardInterrupt:
    print_system("\nSaving state and exiting...")
    twitter_state.save()
    sys.exit(0)
    
except Exception as e:
    print_error(f"Unexpected error: {str(e)}")
    print_error(f"Error type: {type(e).__name__}")
    
    # Continue after error in autonomous mode
    print_system("Continuing after error...")
    await asyncio.sleep(MENTION_CHECK_INTERVAL)