initial move

.gitignore

@@ -0,0 +1,18 @@
+# Environment and local config
+.env
+config.py
+
+# Compiled Python artifacts
+*.pyc
+__pycache__/
+*__pycache__*
+
+# Asset folders
+assets/
+
+# Storyboard sessions and local DBs
+storyboard/
+memory.db
+*.sqlite3
+*.png
+services/__pycache__/message_factory.cpython-311.pyc

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ramsi Kalia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,14 +1,171 @@
+# Agentic Comic Generator
+
+![Python](https://img.shields.io/badge/language-python-blue)
+![Gradio](https://img.shields.io/badge/frontend-Gradio-orange)
+![Modal](https://img.shields.io/badge/backend-Modal-lightgrey)
+
+> 🎨 Multi-agent AI system for generating comic panels from story prompts
+
+A multi-agent AI system that transforms user prompts into illustrated comic panels. Agent Brown handles narrative logic and dialogue. Agent Bayko renders the visuals. Designed as an experiment in agent collaboration, creative storytelling, and generative visuals.
+
+## 🎗️Key Features
+
+- Modular agents for dialogue and image generation
+- Prompt-to-panel storytelling pipeline
+- Gradio-powered web interface
+- Easily extendable for TTS, styles, or emotion tagging
+
+## ✍️ Status
+
+Currently under active development for experimentation and portfolio.
+
+## 📁 Directory Structure
+
+```text
+  project-root/
+├── app.py                     # Entrypoint for Gradio
+├── api/                       # FastAPI routes and logic
+├── agents/
+│   ├── brown.py
+│   └── bayko.py
+├── plugins/
+│   ├── base.py
+│   └── tts_plugin.py
+├── services/
+│   └── ai_service.py
+├── config.py
+├── modal_app.py
+├── storyboard/                # Where all output sessions go
+│   └── session_xxx/
+├── requirements.txt
+├── README.md
+└── tech_specs.md
+```
+
+## 💡 Use Case
+
+A user enters a storytelling prompt via a secure WebUI.  
+The system responds with:
+
+- Stylized dialogue
+- Rendered comic panels
+- Optional voiceover narration
+
+Behind the scenes, two agents — Bayko and Brown — process and generate the comic collaboratively while remaining isolated via network boundaries.
+
 ---
-title: Agentic Comic Generator
-emoji: 🦀
-colorFrom: indigo
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.33.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: A multi-agent system comic generator
+
+## 📞 Agent Communication & Storage
+
+## 👥 Agent Roles
+
+Two core agents form the backbone of this system:
+
+- 🤖 **Agent Brown** – The front-facing orchestrator. It receives the user’s prompt, tags the style, validates inputs, and packages the story plan for execution.
+- 🧠 **Agent Bayko** – The creative engine. It handles image, audio, and subtitle generation based on the structured story plan from Brown.
+
+Each agent operates in isolation but contributes to the shared goal of generating cohesive, stylized comic outputs.
+
+### Agent Brown
+
+- 🔹 Input validator, formatter, and storyboard author
+- ✨ Adds style tags ("Ghibli", "tragedy", etc.)
+- 📦 Writes JSON packages for Bayko
+- 🛡️ Includes moderation tools, profanity filter
+
+### Agent Bayko
+
+- 🧠 Reads storyboard.json and routes via MCP
+- 🛠️ Toolchain orchestration (SDXL, TTS, Subtitler)
+- 🎞️ Output assembly logic
+- 🔄 Writes final output + metadata
+
+Brown and Bayko operate in a feedback loop, refining outputs collaboratively across multiple turns, simulating human editorial workflows.
+
+## 🔁 Agent Feedback Loop
+
+This system features a multi-turn agent interaction flow, where Brown and Bayko collaborate via structured JSON messaging.
+
+### Step-by-Step Collaboration
+
+1. **User submits prompt via WebUI**  
+   → Brown tags style, checks profanity, and prepares a `storyboard.json`.
+
+2. **Brown sends JSON to Bayko via shared storage**  
+   → Includes panel count, style tags, narration request, and subtitles config.
+
+3. **Bayko processes each panel sequentially**  
+   → For each, it generates:
+
+   - `panel_X.png` (image)
+   - `panel_X.mp3` (narration)
+   - `panel_X.vtt` (subtitles)
+
+4. **Brown reviews Bayko’s output against the prompt**
+
+   - If all panels match: compile final comic.
+   - If mismatch: returns annotated JSON with `refinement_request`.
+
+5. **UI reflects agent decisions**  
+   → Shows messages like “Waiting on Bayko…” or “Refining… hang tight!”
+
+This feedback loop allows for **multi-turn refinement**, **moderation hooks**, and extensibility (like emotion tagging or memory-based rejections).
+
+### User Interaction
+
+- When the user submits a prompt, the system enters a "processing" state.
+- If Brown flags an issue, the UI displays a message such as “Refining content… please wait.”
+- This feedback loop can be extended for multi-turn interactions, allowing further refinement for higher-quality outputs.
+
+This modular design not only demonstrates the agentic behavior of the system but also allows for future expansions such as incorporating memory and adaptive feedback over multiple turns.
+
+## ⚙️ Example Prompt
+
+```text
+Prompt: “A moody K-pop idol finds a puppy on the street. It changes everything.”
+Style: 4-panel, Studio Ghibli, whisper-soft lighting
+Language: Korean with English subtitles
+Extras: Narration + backing music
+```
+
+For detailed multi-turn logic and JSON schemas, see [Feedback Loop Implementation](./tech_specs.md#-multi-turn-agent-communication).
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 🧠 System Architecture
+
+### 🏗️ Technical Overview
+
+The system combines **FastAPI** backend services, **Gradio** frontend, **Modal** compute scaling, and **LlamaIndex** agent orchestration to create a sophisticated multi-agent workflow.
+
+```mermaid
+graph TD
+    A[👤 User Input<br/>Gradio Interface] --> B[🤖 Agent Brown<br/>Orchestrator]
+    B --> C[🧠 LlamaIndex<br/>Memory & State]
+    B --> D[📨 JSON Message Queue<br/>Agent Communication]
+    D --> E[🎨 Agent Bayko<br/>Content Generator]
+    E --> F[☁️ Modal Inference<br/>Compute Layer]
+
+    subgraph "🎯 Sponsor Tool Integration"
+        G[🤖 OpenAI API<br/>Dialogue Generation]
+        H[🦙 Mistral API<br/>Style & Tone]
+        I[🤗 HuggingFace<br/>SDXL Models]
+        J[⚡ Modal Labs<br/>Serverless Compute]
+    end
+
+    F --> G
+    F --> H
+    F --> I
+    E --> J
+
+    E --> K[✅ Content Validation]
+    K --> L{Quality Check}
+    L -->|❌ Needs Refinement| D
+    L -->|✅ Approved| M[📦 Final Assembly]
+    M --> N[🎨 Comic Output<br/>Gradio Display]
+
+    style A fill:#e1f5fe
+    style B fill:#f3e5f5
+    style E fill:#e8f5e8
+    style F fill:#fff3e0
+```

agents/__init__.py

@@ -0,0 +1 @@
+"""Bayko agents package"""

agents/bayko.py

@@ -0,0 +1,1017 @@
+"""
+Agent Bayko - The Creative Engine
+
+Agent Bayko is the content generation specialist that handles:
+- Reading structured JSON requests from Agent Brown
+- Generating comic panel images using SDXL via Modal compute
+- Creating audio narration using TTS services
+- Generating subtitle files in VTT format
+- Managing output files in the session directory structure
+- Updating metadata as content is generated
+- Supporting refinement requests from Brown's feedback loop
+"""
+
+import uuid
+import json
+import time
+import os
+import logging
+from datetime import datetime
+from typing import Dict, List, Optional, Any, Tuple, Union, cast
+from pathlib import Path
+from dataclasses import dataclass, asdict, field
+from enum import Enum
+
+from openai import OpenAI
+from openai.types.chat import ChatCompletion
+from llama_index.llms.openai import OpenAI as LlamaOpenAI
+
+# Core services
+from services.unified_memory import AgentMemory
+from services.session_manager import SessionManager as ServiceSessionManager
+from services.message_factory import MessageFactory, AgentMessage, MessageType
+
+# Tools
+from agents.bayko_tools import ModalImageGenerator, ModalCodeExecutor
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class GenerationStatus(Enum):
+    """Status of content generation"""
+
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    REFINEMENT_NEEDED = "refinement_needed"
+
+
+class ContentType(Enum):
+    """Types of content Bayko can generate"""
+
+    IMAGE = "image"
+    AUDIO = "audio"
+    SUBTITLES = "subtitles"
+    METADATA = "metadata"
+
+
+@dataclass
+class PanelContent:
+    """Content and metadata for a single comic panel"""
+
+    panel_id: int
+    description: str
+    enhanced_prompt: str = ""  # LLM-enhanced prompt
+    image_path: Optional[str] = None
+    image_url: Optional[str] = None
+    audio_path: Optional[str] = None
+    subtitles_path: Optional[str] = None
+    status: str = "pending"
+    generation_time: float = 0.0
+    style_tags: List[str] = field(default_factory=list)
+    errors: List[str] = field(default_factory=list)
+    refinement_history: List[Dict[str, Any]] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class GenerationResult:
+    """Result of a generation or refinement request"""
+
+    session_id: str
+    panels: List[PanelContent]
+    metadata: Dict[str, Any]
+    status: GenerationStatus
+    total_time: float
+    errors: List[str] = field(default_factory=list)
+    refinement_applied: bool = False
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "session_id": self.session_id,
+            "panels": [panel.to_dict() for panel in self.panels],
+            "metadata": self.metadata,
+            "status": self.status.value,
+            "total_time": self.total_time,
+            "errors": self.errors,
+            "refinement_applied": self.refinement_applied,
+        }
+
+
+class AgentBayko:
+    """
+    Agent Bayko - The Creative Engine
+
+    Main responsibilities:
+    - Process structured requests from Agent Brown
+    - Generate comic panel images via SDXL/Modal
+    - Create audio narration using TTS
+    - Generate subtitle files in VTT format
+    - Manage session file organization
+    - Support refinement requests and feedback loops
+    - Update metadata and performance metrics
+    """
+
+    def __init__(self, llm: Optional[LlamaOpenAI] = None):
+        # Core tools
+        self.image_generator = ModalImageGenerator()
+        self.code_executor = ModalCodeExecutor()
+        self.llm = llm
+
+        # Session state
+        self.current_session: Optional[str] = None
+        self.session_manager: Optional[ServiceSessionManager] = None
+        self.memory: Optional[AgentMemory] = None
+        self.message_factory: Optional[MessageFactory] = None
+
+        # Stats tracking
+        self.generation_stats = {
+            "panels_generated": 0,
+            "refinements_applied": 0,
+            "total_time": 0.0,
+            "errors": [],
+        }
+
+    async def process_generation_request(self, message: Any) -> AgentMessage:
+        """
+        Process generation request from Agent Brown
+
+        Args:
+            message: Request from Brown (can be direct dict or wrapped message)
+
+        Returns:
+            AgentMessage with generated content and metadata
+        """
+        start_time = time.time()
+
+        # Handle different input types from Brown
+        if isinstance(message, list):
+            # If it's a list, it's probably a chat history - extract the last user message
+            if message and hasattr(message[-1], "content"):
+                # Try to parse JSON from the content
+                try:
+                    import json
+
+                    payload = json.loads(message[-1].content)
+                    session_id = payload.get("session_id", "hackathon_session")
+                except:
+                    # Fallback - create basic payload
+                    payload = {
+                        "prompt": (
+                            str(message[-1].content)
+                            if message
+                            else "Generate a comic"
+                        ),
+                        "session_id": "hackathon_session",
+                    }
+                    session_id = "hackathon_session"
+            else:
+                # Empty list fallback
+                payload = {
+                    "prompt": "Generate a comic",
+                    "session_id": "hackathon_session",
+                }
+                session_id = "hackathon_session"
+        elif isinstance(message, dict):
+            # Handle both direct dict from Brown and wrapped message formats
+            if "payload" in message:
+                # Wrapped message format
+                payload = message.get("payload", {})
+                context = message.get("context", {})
+                session_id = context.get("session_id", "hackathon_session")
+            else:
+                # Direct dict from Brown workflow
+                payload = message
+                session_id = message.get("session_id", "hackathon_session")
+        else:
+            # Fallback for any other type
+            payload = {
+                "prompt": str(message),
+                "session_id": "hackathon_session",
+            }
+            session_id = "hackathon_session"
+
+        if not session_id:
+            session_id = "hackathon_session"
+
+        # Initialize session
+        self._initialize_session(session_id, None)
+        logger.info(f"Processing generation request for session {session_id}")
+
+        # Extract generation parameters - handle both Brown formats
+        prompt = payload.get("enhanced_prompt") or payload.get("prompt", "")
+        original_prompt = payload.get("original_prompt", prompt)
+        style_tags = payload.get("style_tags", [])
+        panel_count = payload.get("panels", 4)
+
+        # Create panel descriptions (using Brown's enhanced prompt for now)
+        panel_prompts = self._create_panel_descriptions(
+            prompt, panel_count, payload.get("style_config", {})
+        )
+
+        # Generate content for each panel in parallel
+        panels = []
+        errors = []
+
+        for i, description in enumerate(panel_prompts, 1):
+            try:
+                panel = await self._generate_panel_content(
+                    panel_id=i,
+                    description=description,
+                    enhanced_prompt=prompt,  # Using Brown's enhanced prompt directly
+                    style_tags=style_tags,
+                    language="english",  # Default for now
+                    extras=[],  # Simplified for now
+                    session_id=session_id,
+                )
+                panels.append(panel)
+                self._update_generation_progress(i, panel_count)
+
+            except Exception as e:
+                error_msg = f"Failed to generate panel {i}: {str(e)}"
+                logger.error(error_msg)
+                errors.append(error_msg)
+                panels.append(
+                    PanelContent(
+                        panel_id=i, description=description, errors=[error_msg]
+                    )
+                )
+
+        # Calculate total time
+        total_time = time.time() - start_time
+
+        # Create metadata
+        metadata = self._create_generation_metadata(
+            payload, panels, total_time, errors
+        )
+
+        # Update session metadata
+        self.update_metadata(metadata)
+        self._save_current_state(message, panels, metadata)
+
+        # Create result object
+        result = GenerationResult(
+            session_id=session_id,
+            panels=panels,
+            metadata=metadata,
+            status=(
+                GenerationStatus.COMPLETED
+                if not errors
+                else GenerationStatus.FAILED
+            ),
+            total_time=total_time,
+            errors=errors,
+        )
+
+        # Create response message
+        if self.memory:
+            self.memory.add_message(
+                "assistant",
+                f"Generated {len(panels)} panels in {total_time:.2f}s",
+            )
+
+        if self.message_factory:
+            return self.message_factory.create_approval_message(
+                result.to_dict(),
+                {
+                    "overall_score": 1.0 if not errors else 0.7,
+                    "generation_successful": True,
+                    "panels_generated": len(panels),
+                    "total_time": total_time,
+                },
+                1,  # Initial iteration
+            )
+
+        # Create a plain message if no factory available
+        plain_message = AgentMessage(
+            message_id=f"msg_{uuid.uuid4().hex[:8]}",
+            timestamp=datetime.utcnow().isoformat() + "Z",
+            sender="agent_bayko",
+            recipient="agent_brown",
+            message_type="generation_response",
+            payload=result.to_dict(),
+            context=context,
+        )
+
+        return plain_message
+
+    async def process_refinement_request(
+        self, message: Dict[str, Any]
+    ) -> AgentMessage:
+        """Process refinement request from Agent Brown"""
+
+        start_time = time.time()
+
+        # Extract request data
+        payload = message.get("payload", {})
+        context = message.get("context", {})
+        session_id = context.get("session_id")
+        iteration = context.get("iteration", 1)
+
+        if not session_id:
+            raise ValueError("No session_id provided in message context")
+
+        # Initialize session if needed
+        if self.current_session != session_id:
+            self._initialize_session(
+                session_id, context.get("conversation_id")
+            )
+
+        # Extract refinement data
+        original_content = payload.get("original_content", {})
+        feedback = payload.get("feedback", {})
+        focus_areas = payload.get("focus_areas", [])
+        refinements = payload.get("specific_improvements", [])
+
+        # Log refinement request
+        if self.memory:
+            self.memory.add_message(
+                "user",
+                f"Refinement request received - Areas: {', '.join(focus_areas)}",
+            )
+
+        # Generate new panels for ones needing refinement
+        panels = []
+        errors = []
+
+        # Convert original panels to PanelContent objects
+        original_panels = [
+            PanelContent(
+                panel_id=p.get("panel_id"),
+                description=p.get("description", ""),
+                enhanced_prompt=p.get("enhanced_prompt", ""),
+                image_path=p.get("image_path"),
+                image_url=p.get("image_url"),
+                style_tags=p.get("style_tags", []),
+                status=p.get("status", "pending"),
+                generation_time=p.get("generation_time", 0.0),
+                errors=p.get("errors", []),
+            )
+            for p in original_content.get("panels", [])
+        ]
+
+        # Process each panel
+        for panel in original_panels:
+            try:
+                if any(
+                    area in focus_areas
+                    for area in ["visual_quality", "style_consistency"]
+                ):
+                    # Step 1: Improve prompt based on feedback
+                    improved_prompt = self._improve_prompt_with_feedback(
+                        original_prompt=panel.enhanced_prompt,
+                        feedback=feedback,
+                        improvements=refinements,
+                    )
+
+                    # Step 2: Generate new panel with improved prompt
+                    refined_panel = await self._generate_panel_content(
+                        panel_id=panel.panel_id,
+                        description=panel.description,
+                        enhanced_prompt=improved_prompt,  # Use improved prompt
+                        style_tags=panel.style_tags,
+                        language="english",
+                        extras=[],
+                        session_id=session_id,
+                    )
+
+                    # Add refinement history
+                    refined_panel.refinement_history.append(
+                        {
+                            "iteration": iteration,
+                            "feedback": feedback,
+                            "improvements": refinements,
+                            "original_prompt": panel.enhanced_prompt,
+                            "refined_prompt": improved_prompt,
+                        }
+                    )
+                    panels.append(refined_panel)
+                else:
+                    # Keep original panel
+                    panels.append(panel)
+
+            except Exception as e:
+                error_msg = (
+                    f"Failed to refine panel {panel.panel_id}: {str(e)}"
+                )
+                logger.error(error_msg)
+                errors.append(error_msg)
+                panels.append(panel)  # Keep original on error
+
+        total_time = time.time() - start_time
+
+        # Create metadata
+        metadata = {
+            "refinement": {
+                "iteration": iteration,
+                "feedback": feedback,
+                "improvements": refinements,
+                "focus_areas": focus_areas,
+                "panels_refined": len(
+                    [p for p in panels if len(p.refinement_history) > 0]
+                ),
+                "total_time": total_time,
+            },
+            "timestamp": datetime.utcnow().isoformat() + "Z",
+        }
+
+        # Save state
+        self._save_current_state(message, panels, metadata)
+
+        # Create result
+        result = GenerationResult(
+            session_id=session_id,
+            panels=panels,
+            metadata=metadata,
+            status=(
+                GenerationStatus.COMPLETED
+                if not errors
+                else GenerationStatus.FAILED
+            ),
+            total_time=total_time,
+            errors=errors,
+            refinement_applied=True,
+        )
+
+        # Log completion
+        if self.memory:
+            self.memory.add_message(
+                "assistant",
+                f"Refined {len([p for p in panels if len(p.refinement_history) > 0])} panels in {total_time:.2f}s",
+            )
+
+        # Create response message
+        if self.message_factory:
+            return self.message_factory.create_approval_message(
+                result.to_dict(),
+                {
+                    "overall_score": 1.0 if not errors else 0.7,
+                    "refinement_successful": True,
+                    "panels_refined": len(
+                        [p for p in panels if len(p.refinement_history) > 0]
+                    ),
+                    "total_time": total_time,
+                    "iteration": iteration,
+                },
+                iteration,
+            )
+
+        # Fallback to direct response if no message factory
+        return AgentMessage(
+            message_id=f"msg_{uuid.uuid4().hex[:8]}",
+            timestamp=datetime.utcnow().isoformat() + "Z",
+            sender="agent_bayko",
+            recipient="agent_brown",
+            message_type="refinement_response",
+            payload=result.to_dict(),
+            context=context,
+        )
+
+    def _create_panel_descriptions(
+        self, prompt: str, panel_count: int, style_config: Dict[str, Any]
+    ) -> List[str]:
+        """
+        Use mini LLM to break down the story prompt into panel descriptions
+
+        Args:
+            prompt: The main story prompt
+            panel_count: Number of panels to generate
+            style_config: Style configuration for the panels
+
+        Returns:
+            List of panel descriptions
+        """
+        if not self.llm:
+            # Fallback to basic panel descriptions if LLM is not initialized
+            logger.warning("LLM not available, using basic panel descriptions")
+            return [
+                f"{prompt} (Panel {i+1} of {panel_count})"
+                for i in range(panel_count)
+            ]
+
+        try:
+            system_prompt = f"""You are a comic storyboarding expert. Break down this story into {panel_count} engaging and visually interesting sequential panels.
+            For each panel:
+            - Focus on key narrative moments
+            - Include visual composition guidance
+            - Maintain continuity between panels
+            - Consider dramatic timing and pacing
+            DO NOT include panel numbers or "Panel X:" prefixes.
+            Return ONLY the panel descriptions, one per line.
+            Style notes: {json.dumps(style_config, indent=2)}"""
+
+            client = OpenAI()
+            response = client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt},
+                ],
+                temperature=0.7,
+                max_tokens=1000,
+            )
+            # Extract panel descriptions
+            descriptions = []
+            if response.choices[0].message.content:
+                # Split on newlines and filter out empty lines
+                descriptions = [
+                    d.strip()
+                    for d in response.choices[0].message.content.split("\n")
+                    if d.strip()
+                ]
+
+            # Ensure we have exactly panel_count descriptions
+            if len(descriptions) < panel_count:
+                # Pad with basic descriptions if needed
+                descriptions.extend(
+                    [
+                        f"{prompt} (Panel {i+1})"
+                        for i in range(len(descriptions), panel_count)
+                    ]
+                )
+            elif len(descriptions) > panel_count:
+                # Trim extra descriptions
+                descriptions = descriptions[:panel_count]
+
+            return descriptions
+
+        except Exception as e:
+            logger.error(f"Failed to create panel descriptions: {e}")
+            # Fallback to basic descriptions
+            return [
+                f"{prompt} (Panel {i+1} of {panel_count})"
+                for i in range(panel_count)
+            ]
+
+    def generate_prompt_from_description(
+        self,
+        description: str,
+        style_tags: List[str],
+        mood: Optional[str] = None,
+    ) -> str:
+        """
+        Use mini LLM to convert panel descriptions into SDXL-optimized prompts
+
+        Args:
+            description: The panel description to optimize
+            style_tags: List of style tags to incorporate
+
+        Returns:
+            SDXL-optimized prompt
+        """
+        if not self.llm:
+            # Fallback to basic prompt if LLM is not initialized
+            style_str = ", ".join(style_tags) if style_tags else ""
+            return f"{description} {style_str}".strip()
+
+        try:
+            system_prompt = """You are an expert at crafting prompts for SDXL image generation.
+            Convert the given panel description into an optimized SDXL prompt that will generate a high-quality comic panel.
+            Follow these guidelines:
+            - Be specific about visual elements and composition
+            - Maintain artistic consistency with the provided style
+            - Use clear, direct language that SDXL will understand
+            - Focus on key details that drive the narrative
+            Return ONLY the optimized prompt text with no additional formatting."""
+
+            style_context = ""
+            if style_tags:
+                style_context = (
+                    f"\nStyle requirements: {', '.join(style_tags)}"
+                )
+
+            client = OpenAI()
+            response = client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {
+                        "role": "user",
+                        "content": f"{description}{style_context}",
+                    },
+                ],
+                temperature=0.5,
+                max_tokens=500,
+            )
+
+            if response.choices[0].message.content:
+                return response.choices[0].message.content.strip()
+
+            # Fallback if no valid response
+            style_str = ", ".join(style_tags) if style_tags else ""
+            return f"{description} {style_str}".strip()
+
+        except Exception as e:
+            logger.error(f"Failed to optimize prompt: {e}")
+            # Fallback to basic prompt
+            style_str = ", ".join(style_tags) if style_tags else ""
+            return f"{description} {style_str}".strip()
+
+    def _update_generation_progress(
+        self, current_panel: int, total_panels: int
+    ) -> None:
+        """Update generation progress tracking"""
+        progress = (current_panel / total_panels) * 100
+        logger.info(
+            f"Generation Progress: {progress:.1f}% ({current_panel}/{total_panels})"
+        )
+
+        self.generation_stats["panels_generated"] += 1
+
+    async def _generate_panel_content(
+        self,
+        panel_id: int,
+        description: str,
+        enhanced_prompt: str,
+        style_tags: List[str],
+        language: str = "english",
+        extras: Optional[List[str]] = None,
+        session_id: Optional[str] = None,
+    ) -> PanelContent:
+        """
+        Generate content for a single panel
+
+        Args:
+            panel_id: Panel identifier
+            description: Raw panel description
+            enhanced_prompt: Initial enhanced prompt
+            style_tags: Style tags to apply
+            language: Language for text (default: english)
+            extras: Additional generation parameters
+            session_id: Current session ID
+
+        Returns:
+            PanelContent object with generated content
+        """
+        start_time = time.time()
+        extras = extras or []
+
+        try:
+            # Step 1: Optimize prompt for SDXL using LLM
+            optimized_prompt = self.generate_prompt_from_description(
+                description=description, style_tags=style_tags
+            )
+            # Step 2: Generate image using optimized prompt
+            generated_path, gen_time = (
+                await self.image_generator.generate_panel_image(
+                    prompt=optimized_prompt,
+                    style_tags=style_tags,
+                    panel_id=panel_id,
+                    session_id=session_id if session_id is not None else "",
+                )
+            )
+
+            # Step 3: Create panel content object
+            panel = PanelContent(
+                panel_id=panel_id,
+                description=description,
+                enhanced_prompt=optimized_prompt,  # Store the optimized prompt
+                image_path=generated_path,
+                image_url=(
+                    f"file://{generated_path}" if generated_path else None
+                ),
+                style_tags=style_tags,
+                status=GenerationStatus.COMPLETED.value,
+                generation_time=gen_time,
+            )
+
+            return panel
+
+        except Exception as e:
+            error_msg = f"Panel {panel_id} generation failed: {str(e)}"
+            logger.error(error_msg)
+
+            return PanelContent(
+                panel_id=panel_id,
+                description=description,
+                enhanced_prompt=enhanced_prompt,
+                style_tags=style_tags,
+                status=GenerationStatus.FAILED.value,
+                generation_time=time.time() - start_time,
+                errors=[error_msg],
+            )
+
+    def _create_generation_metadata(
+        self,
+        payload: Dict[str, Any],
+        panels: List[PanelContent],
+        total_time: float,
+        errors: List[str],
+    ) -> Dict[str, Any]:
+        """Create metadata for generation request"""
+        return {
+            "request": {
+                "prompt": payload.get("prompt", ""),
+                "style_tags": payload.get("style_tags", []),
+                "panels": len(panels),
+            },
+            "generation": {
+                "total_time": total_time,
+                "panels_completed": len(
+                    [p for p in panels if p.status == "completed"]
+                ),
+                "panels_failed": len(
+                    [p for p in panels if p.status == "failed"]
+                ),
+                "errors": errors,
+            },
+            "timestamp": datetime.utcnow().isoformat() + "Z",
+        }
+
+    def _save_current_state(
+        self,
+        message: Dict[str, Any],
+        panels: List[PanelContent],
+        metadata: Dict[str, Any],
+    ) -> None:
+        """Save current state to session storage"""
+        if not self.session_manager:
+            return
+
+        state_data = {
+            "current_message": message,
+            "panels": [panel.to_dict() for panel in panels],
+            "metadata": metadata,
+            "timestamp": datetime.utcnow().isoformat() + "Z",
+        }
+
+        state_file = Path(
+            f"storyboard/{self.current_session}/agents/bayko_state.json"
+        )
+        state_file.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(state_file, "w") as f:
+            json.dump(state_data, f, indent=2)
+
+    def get_generation_stats(self) -> Dict[str, Any]:
+        """Get current generation statistics"""
+        return self.generation_stats.copy()
+
+    def _initialize_session(
+        self, session_id: str, conversation_id: Optional[str] = None
+    ):
+        """Initialize session with unified memory system (matches Brown's pattern)"""
+        self.current_session = session_id
+        conversation_id = conversation_id or f"conv_{session_id}"
+
+        # Initialize session-specific services (matches Brown's pattern)
+        self.session_manager = ServiceSessionManager(
+            session_id, conversation_id
+        )
+        self.message_factory = MessageFactory(session_id, conversation_id)
+        self.memory = AgentMemory(session_id, "bayko")
+
+        # Create Bayko's directory structure
+        self._create_session_directories(session_id)
+
+        print(f"🧠 Bayko initialized unified memory for session {session_id}")
+        logger.info(f"Bayko session initialized: {session_id}")
+
+    def _create_session_directories(self, session_id: str):
+        """Create Bayko's session directory structure"""
+        session_dir = Path(f"storyboard/{session_id}")
+        content_dir = session_dir / "content"
+        agents_dir = session_dir / "agents"
+        iterations_dir = session_dir / "iterations"
+        output_dir = session_dir / "output"
+
+        # Create directory structure
+        for dir_path in [content_dir, agents_dir, iterations_dir, output_dir]:
+            dir_path.mkdir(parents=True, exist_ok=True)
+
+    def update_metadata(self, metadata: Dict[str, Any]):
+        """Update content metadata"""
+        if not self.current_session:
+            return
+
+        session_dir = Path(f"storyboard/{self.current_session}")
+        content_dir = session_dir / "content"
+        content_dir.mkdir(parents=True, exist_ok=True)
+        metadata_file = content_dir / "metadata.json"
+
+        # Load existing metadata if it exists
+        existing_metadata = {}
+        if metadata_file.exists():
+            with open(metadata_file, "r") as f:
+                existing_metadata = json.load(f)
+
+        # Merge with new metadata
+        existing_metadata.update(metadata)
+        existing_metadata["updated_at"] = datetime.utcnow().isoformat() + "Z"
+
+        with open(metadata_file, "w") as f:
+            json.dump(existing_metadata, f, indent=2)
+
+    def save_iteration_data(self, iteration: int, data: Dict[str, Any]):
+        """Save iteration-specific data"""
+        if not self.current_session:
+            return
+
+        session_dir = Path(f"storyboard/{self.current_session}")
+        iterations_dir = session_dir / "iterations"
+        iterations_dir.mkdir(parents=True, exist_ok=True)
+        iteration_file = iterations_dir / f"v{iteration}_generation.json"
+
+        with open(iteration_file, "w") as f:
+            json.dump(data, f, indent=2)
+
+    def save_bayko_state(self, state_data: Dict[str, Any]):
+        """Save Bayko's current state"""
+        if not self.current_session:
+            return
+
+        session_dir = Path(f"storyboard/{self.current_session}")
+        agents_dir = session_dir / "agents"
+        agents_dir.mkdir(parents=True, exist_ok=True)
+        state_file = agents_dir / "bayko_state.json"
+
+        with open(state_file, "w") as f:
+            json.dump(state_data, f, indent=2)
+
+    def get_session_info(self) -> Dict[str, Any]:
+        """Get current session information (matches Brown's interface)"""
+        memory_size = 0
+        if self.memory:
+            try:
+                memory_size = self.memory.get_memory_size()
+            except:
+                memory_size = 0
+
+        return {
+            "session_id": self.current_session,
+            "memory_size": memory_size,
+            "generation_stats": self.generation_stats,
+        }
+
+    def _improve_prompt_with_feedback(
+        self,
+        original_prompt: str,
+        feedback: Dict[str, Any],
+        improvements: List[str],
+    ) -> str:
+        """
+        Use mini LLM to improve a prompt based on feedback
+
+        Args:
+            original_prompt: The original prompt to improve
+            feedback: Dictionary containing feedback data
+            improvements: List of specific improvements to make
+
+        Returns:
+            Improved prompt
+        """
+        if not self.llm:
+            # Fallback to original prompt if LLM is not initialized
+            logger.warning("LLM not available, using original prompt")
+            return original_prompt
+
+        try:
+            # Construct feedback context
+            feedback_str = ""
+            if feedback:
+                feedback_str = "Feedback:\n"
+                for key, value in feedback.items():
+                    feedback_str += f"- {key}: {value}\n"
+
+            improvements_str = ""
+            if improvements:
+                improvements_str = "Requested improvements:\n"
+                for imp in improvements:
+                    improvements_str += f"- {imp}\n"
+
+            system_prompt = """You are an expert at refining SDXL image generation prompts.
+            Analyze the feedback and improve the original prompt while maintaining its core narrative elements.
+            Focus on addressing the specific feedback points and requested improvements.
+            Return ONLY the improved prompt with no additional formatting or explanations."""
+
+            client = OpenAI()
+            response = client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {
+                        "role": "user",
+                        "content": f"Original prompt: {original_prompt}\n\n{feedback_str}\n{improvements_str}",
+                    },
+                ],
+                temperature=0.5,
+                max_tokens=500,
+            )
+
+            if response.choices[0].message.content:
+                return response.choices[0].message.content.strip()
+
+            # Fallback if no valid response
+            return original_prompt
+
+        except Exception as e:
+            logger.error(f"Failed to improve prompt: {e}")
+            # Fallback to original prompt
+            return original_prompt
+
+
+# Example usage and testing
+async def main():
+    """Example usage of Agent Bayko leveraging the BaykoWorkflow"""
+    from agents.bayko_workflow import create_agent_bayko
+    import os
+
+    # Create Bayko agent using the factory function
+    bayko_workflow = create_agent_bayko(
+        os.getenv("OPENAI_API_KEY")
+    )  # Initialize a test session
+    from services.session_id_generator import SessionIdGenerator
+
+    session_id = SessionIdGenerator.create_session_id("test")
+    conversation_id = f"conv_{session_id}"
+    bayko_workflow.initialize_session(session_id, conversation_id)
+
+    test_message = {
+        "message_id": "msg_12345",
+        "timestamp": "2025-01-15T10:30:00Z",
+        "sender": "agent_brown",
+        "recipient": "agent_bayko",
+        "message_type": "generation_request",
+        "payload": {
+            "prompt": "A moody K-pop idol finds a puppy on the street. It changes everything. Visual style: whimsical, nature, soft_lighting, watercolor, mood: peaceful, color palette: warm_earth_tones",
+            "original_prompt": "A moody K-pop idol finds a puppy on the street. It changes everything.",
+            "style_tags": [
+                "whimsical",
+                "nature",
+                "soft_lighting",
+                "watercolor",
+            ],
+            "panels": 4,
+            "language": "korean",
+            "extras": ["narration", "subtitles"],
+            "style_config": {
+                "primary_style": "studio_ghibli",
+                "mood": "peaceful",
+                "color_palette": "warm_earth_tones",
+                "confidence": 0.9,
+            },
+            "generation_params": {
+                "quality": "high",
+                "aspect_ratio": "16:9",
+                "panel_layout": "sequential",
+            },
+        },
+        "context": {
+            "conversation_id": conversation_id,
+            "session_id": session_id,
+            "iteration": 1,
+            "previous_feedback": None,
+            "validation_score": 0.85,
+        },
+    }
+
+    # Process generation request
+    print("🎨 Processing generation request...")
+    result = bayko_workflow.process_generation_request(test_message)
+
+    # Print generation results
+    print("\n✨ Generation completed!")
+    print("-" * 40)
+    print(f"Result type: {type(result)}")
+
+    if isinstance(result, str):
+        # For workflow result
+        print(f"Generation Result: {result}")
+    else:
+        # For direct Bayko result
+        result_data = result.payload
+        print(f"\nPanels Generated: {len(result_data['panels'])}")
+        print(
+            f"Total Time: {result_data['metadata']['generation']['total_time']:.2f}s"
+        )
+        print(
+            f"Success Rate: {result_data['metadata']['generation']['panels_completed']}/{len(result_data['panels'])}"
+        )
+
+        if isinstance(result_data, dict) and result.get("metadata", {}).get(
+            "generation", {}
+        ).get("errors"):
+
+            print("\n⚠️ Errors:")
+            errors = (
+                result_data.get("metadata", {})
+                .get("generation", {})
+                .get("errors")
+            )
+            if not isinstance(errors, list):
+                errors = []
+            for error in errors:
+                print(f"- {error}")
+
+    print("\n✅ Test operations completed successfully!")
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

agents/bayko_tools.py

@@ -0,0 +1,219 @@
+import json
+import base64
+
+# import uuid  # Currently unused
+import asyncio
+from datetime import datetime
+from typing import Dict, List, Optional, Any, Tuple
+from pathlib import Path
+from dataclasses import dataclass, asdict
+from enum import Enum
+import logging
+import time
+import os
+import random
+import modal
+import modal
+import random
+
+# Core services - Updated to match Brown's memory system
+from services.unified_memory import AgentMemory
+from services.session_manager import SessionManager as ServiceSessionManager
+from services.message_factory import MessageFactory, AgentMessage, MessageType
+from services.session_id_generator import SessionIdGenerator
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class ModalImageGenerator:
+    """
+    MCP client implementation for SDXL Turbo image generation via Modal compute
+    """
+
+    def __init__(self):
+        self.model_loaded = False
+        logger.info("ModalImageGenerator initialized")
+        # Import the Modal app here to ensure it's only loaded when needed
+        try:
+            from tools.image_generator import generate_comic_panel, app
+
+            self.generate_panel = generate_comic_panel
+            self.app = app
+            self.model_loaded = True
+        except ImportError as e:
+            logger.error(f"Failed to import Modal image generator: {e}")
+
+    async def generate_panel_image(
+        self,
+        prompt: str,
+        style_tags: List[str],  # Kept for backward compatibility but not used
+        panel_id: int,
+        session_id: str,
+    ) -> Tuple[str, float]:
+        """
+        Generate comic panel image using SDXL via Modal MCP
+        Returns tuple of (image_path, generation_time)
+        """
+        if not self.model_loaded:
+            raise RuntimeError(
+                "Modal image generator not properly initialized"
+            )
+
+        start_time = time.time()
+        try:  # Call the Modal function directly
+            with self.app.run():
+                img_bytes, duration = await self.generate_panel.remote.aio(
+                    prompt=prompt,
+                    panel_id=panel_id,
+                    session_id=session_id,
+                    steps=1,  # Using SDXL Turbo default
+                    seed=42,
+                )
+
+            # Create output path and save the image
+            content_dir = Path(f"storyboard/{session_id}/content")
+            content_dir.mkdir(parents=True, exist_ok=True)
+            image_path = content_dir / f"panel_{panel_id}.png"
+
+            # Save the returned image bytes
+            with open(image_path, "wb") as f:
+                f.write(img_bytes)
+
+            generation_time = time.time() - start_time
+            logger.info(
+                f"Generated image for panel {panel_id} in {generation_time:.2f}s"
+            )
+            return str(image_path), generation_time
+
+        except Exception as e:
+            logger.error(f"Failed to generate image: {e}")
+            raise
+
+
+class ModalCodeExecutor:
+    """
+    Modal code execution sandbox using fries.py for Python script generation and execution
+    """
+
+    def __init__(self):
+        self.app = None
+        self.generate_and_run = None
+        logger.info("ModalCodeExecutor initializing")
+        try:
+            from tools.fries import app, generate_and_run_script
+
+            self.app = app
+            # Store the Modal function directly like in ModalImageGenerator
+            self.generate_and_run = generate_and_run_script
+            logger.info("Successfully loaded Modal fries app")
+        except ImportError as e:
+            logger.error(f"Failed to import Modal fries app: {e}")
+
+    async def execute_code(
+        self, prompt: str, session_id: str
+    ) -> Tuple[str, float]:
+        """
+        Execute code in Modal sandbox for interactive comic elements using fries.py
+
+        Args:
+            prompt: The prompt to generate and run code for
+            session_id: Session identifier for file organization
+
+        Returns:
+            Tuple of (script_file_path, execution_time)
+        """
+        if not self.app or not self.generate_and_run:
+            raise RuntimeError("Modal fries app not properly initialized")
+
+        start_time = time.time()
+
+        try:
+            # Generate animal art with fries
+            animal = random.choice(
+                [
+                    "cat",
+                    "dog",
+                    "fish",
+                    "bird",
+                    "giraffe",
+                    "turtle",
+                    "monkey",
+                    "rabbit",
+                    "puppy",
+                    "animal",
+                ]
+            )
+
+            print(
+                f"\n🤖 Generating an ascii {animal} for you!"
+            )  # Execute code via Modal with the EXACT same prompt structure as main()
+            with self.app.run():
+                result = await self.generate_and_run.remote.aio(
+                    f"""
+                    create a simple ASCII art of a {animal}.
+                    Create ASCII art using these characters: _ - = ~ ^ \\\\ / ( ) [ ] {{ }} < > | . o O @ *
+                    Draw the art line by line with print statements.
+                    Write a short, funny Python script.
+                    Use only basic Python features.
+                    Add a joke or pun about fries in the script.
+                    Make it light-hearted and fun.
+                    End with a message about fries.
+                    Make sure the script runs without errors.
+                    """,
+                    session_id,
+                )
+
+            print("=" * 30)
+            print("\n🎮 Code Output:")
+            print("=" * 30)
+            print("\n\n")
+            print(result["output"])
+
+            print("🍟    🍟     🍟")
+            print("Golden crispy Python fries")
+            print("Coming right up!")
+            print()
+            print("Haha. Just kidding.")
+
+            script_file = f"storyboard/{session_id}/output/fries_for_you.py"
+            os.makedirs(os.path.dirname(script_file), exist_ok=True)
+
+            if result["code"]:
+                # Save the generated code locally
+                with open(script_file, "w") as f:
+                    f.write(result["code"])
+                print("\nGo here to check out your actual custom code:")
+                print(f"👉 Code saved to: {script_file}")
+                print("\n\n\n")
+
+            if result["error"]:
+                print("\n❌ Error:")
+                print("=" * 40)
+                print(result["error"])
+                print("Looks like there was an error during execution.")
+                print("Here are some extra fries to cheer you up!")
+                print("🍟    🍟     🍟")
+                print("   🍟     🍟    ")
+                print("       🍟      ")
+                print("Now with extra machine-learned crispiness.")
+
+            execution_time = time.time() - start_time
+            return script_file, execution_time
+
+        except modal.exception.FunctionTimeoutError:
+            print(
+                "⏰ Script execution timed out after 300 seconds and 3 tries!"
+            )
+            print("Sorry but codestral is having a hard time drawing today.")
+            print("Here's a timeout fry for you! 🍟")
+            print("Here are some extra fries to cheer you up!")
+            print("🍟    🍟     🍟")
+            print("   🍟     🍟    ")
+            print("       🍟      ")
+            print("Now with extra machine-learned crispiness.")
+            raise
+        except Exception as e:
+            logger.error(f"Failed to execute code: {e}")
+            raise

agents/bayko_workflow.py

@@ -0,0 +1,328 @@
+"""
+Agent Bayko LlamaIndex ReAct Workflow
+Hackathon demo showcasing content generation with LLM-enhanced prompts and visible reasoning
+"""
+
+import os
+import json
+import asyncio
+from typing import Optional, Dict, Any, List
+from openai import OpenAI as OpenAIClient
+from llama_index.llms.openai import OpenAI as LlamaOpenAI
+from llama_index.core.agent import ReActAgent
+from llama_index.core.memory import ChatMemoryBuffer
+from llama_index.core.tools import FunctionTool, BaseTool
+
+# Standard library imports
+from pathlib import Path
+from datetime import datetime
+
+# Core services
+from services.unified_memory import AgentMemory
+from services.session_id_generator import SessionIdGenerator
+from services.session_manager import SessionManager
+from services.message_factory import MessageFactory, AgentMessage
+from agents.bayko import AgentBayko
+from agents.bayko_tools import (
+    ModalImageGenerator,
+    ModalCodeExecutor,
+)
+from agents.bayko_workflow_tools import BaykoWorkflowTools
+
+# Custom prompts
+from prompts.bayko_workflow_system_prompt import BAYKO_WORKFLOW_SYSTEM_PROMPT
+
+# Load environment variables
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv()
+except ImportError:
+    pass
+
+from datetime import datetime
+
+openai_api_key = os.getenv("OPENAI_API_KEY")
+
+
+"""
+Handle LLM interactions for prompt enhancement and generation flow
+"""
+
+
+class BaykoWorkflow:
+    """
+    Agent Bayko Workflow using LlamaIndex ReActAgent
+    Showcases LLM-enhanced content generation with visible reasoning
+    """
+
+    def __init__(self, openai_api_key: Optional[str] = None):
+        # Initialize LLM if available and not explicitly disabled
+        self.llm = None
+
+        # Only initialize if api_key is explicitly provided (not None)
+        if openai_api_key is not None:
+            try:
+                self.llm = LlamaOpenAI(
+                    model="gpt-4.1-mini",
+                    api_key=openai_api_key,  # Don't use env var
+                    temperature=0.7,
+                    max_tokens=2048,
+                )
+                print("✓ Initialized LlamaIndex LLM for enhanced prompts")
+            except Exception as e:
+                print(f"⚠️ Could not initialize LlamaIndex LLM: {e}")
+                self.llm = None
+
+        # Initialize core Bayko agent with matching LLM state
+        self.bayko_agent = AgentBayko()
+        if self.llm:
+            self.bayko_agent.llm = self.llm
+
+        # Initialize session services as None
+        self.session_manager = None
+        self.memory = None
+        self.message_factory = None
+
+        # Create Bayko tools
+        self.bayko_tools = BaykoWorkflowTools(self.bayko_agent)
+        self.tools = self.bayko_tools.create_llamaindex_tools()
+
+        # System prompt for ReAct agent
+        self.system_prompt = BAYKO_WORKFLOW_SYSTEM_PROMPT
+
+        # Initialize ReAct agent if we have LLM
+        self.agent = None
+        if self.llm:
+            from typing import cast
+
+            tools_list = cast(List[BaseTool], self.tools)
+            self.agent = ReActAgent.from_tools(
+                tools=tools_list,
+                llm=self.llm,
+                memory=ChatMemoryBuffer.from_defaults(token_limit=4000),
+                system_prompt=self.system_prompt,
+                verbose=True,
+                max_iterations=15,
+            )
+
+    def initialize_workflow(self):
+        """
+        Initialize core workflow components that don't require session context.
+        Session-specific services should be initialized via initialize_session().
+        """
+        # Only initialize the LLM-powered components if not already done
+        if self.llm and not self.agent:
+            # Initialize ReActAgent with LLM-powered tools
+            from typing import cast
+
+            tools_list = cast(List[BaseTool], self.tools)
+            self.agent = ReActAgent.from_tools(
+                tools=tools_list,
+                llm=self.llm,
+                memory=ChatMemoryBuffer.from_defaults(token_limit=4000),
+                system_prompt=self.system_prompt,
+                verbose=True,
+                max_iterations=15,
+            )
+            print("✓ Initialized ReActAgent with tools")
+
+    def initialize_session(
+        self, session_id: str, conversation_id: Optional[str] = None
+    ):
+        """
+        Initialize or reinitialize session-specific services for Bayko workflow.
+        This should be called before processing any requests to ensure proper session context.
+
+        Args:
+            session_id: Unique identifier for this generation session
+            conversation_id: Optional conversation ID. If not provided, will be derived from session_id
+        """
+        conversation_id = conversation_id or f"conv_{session_id}"
+
+        # Initialize or reinitialize session services
+        self.session_manager = SessionManager(session_id, conversation_id)
+        self.memory = AgentMemory(session_id, "bayko")
+        self.message_factory = MessageFactory(session_id, conversation_id)
+
+        # Update Bayko agent with session services
+        self.bayko_agent._initialize_session(session_id, conversation_id)
+
+        # If we have an LLM agent, ensure its memory is aware of the session
+        if self.agent and hasattr(self.agent, "memory"):
+            from llama_index.core.llms import ChatMessage, MessageRole
+
+            self.agent.memory = ChatMemoryBuffer.from_defaults(
+                token_limit=4000,
+                chat_history=[
+                    ChatMessage(
+                        role=MessageRole.SYSTEM,
+                        content=f"Session ID: {session_id}",
+                    )
+                ],
+            )
+
+        print(f"🧠 Bayko workflow initialized for session {session_id}")
+
+    def process_generation_request(self, request_data: Dict[str, Any]) -> str:
+        """
+        Process content generation request using ReActAgent
+
+        Args:
+            request_data: Structured request from Agent Brown
+
+        Returns:
+            Agent's response with generated content
+        """
+        if not self.agent:
+            return self._fallback_generation(request_data)
+
+        try:
+            print("🤖 Agent Bayko ReAct Workflow")
+            print("=" * 60)
+            print(f"📝 Request: {request_data.get('prompt', 'N/A')[:100]}...")
+            print("\n🔄 Bayko Processing...")
+            print("=" * 60)
+
+            # Format request for agent
+            request_prompt = f"""Generate comic content for the following request:
+
+Original Prompt: {request_data.get('original_prompt', '')}
+Enhanced Prompt: {request_data.get('prompt', '')}
+Style Tags: {request_data.get('style_tags', [])}
+Panels: {request_data.get('panels', 4)}
+Session ID: {request_data.get('session_id', 'default')}
+
+Please generate enhanced prompts and create the comic content."""
+
+            # Process with ReActAgent (shows Thought/Action/Observation)
+            response = self.agent.chat(request_prompt)
+
+            print("\n" + "=" * 60)
+            print("🎉 Agent Bayko Response:")
+            print("=" * 60)
+
+            return str(response)
+
+        except Exception as e:
+            error_msg = f"❌ Error in Bayko generation: {str(e)}"
+            print(error_msg)
+            return self._fallback_generation(request_data)
+
+    def _fallback_generation(self, request_data: Dict[str, Any]) -> str:
+        """Fallback generation when ReActAgent is unavailable"""
+        print("⚠️ Using fallback generation (no LLM agent)")
+
+        # Use core Bayko methods directly
+        panels = request_data.get("panels", 4)
+        style_tags = request_data.get("style_tags", [])
+
+        result = {
+            "status": "completed",
+            "method": "fallback",
+            "panels_generated": panels,
+            "style_tags_applied": style_tags,
+            "llm_enhanced": False,
+            "message": f"Generated {panels} panels using fallback methods",
+        }
+
+        return json.dumps(result, indent=2)
+
+    def reset(self):
+        """Reset workflow state for a new session."""
+        if self.memory:
+            self.memory.clear()
+        if self.agent and hasattr(self.agent, "memory"):
+            self.agent.memory = ChatMemoryBuffer.from_defaults(
+                token_limit=4000
+            )
+        self.current_session = None
+        self.session_manager = None
+
+
+def create_agent_bayko(openai_api_key: Optional[str] = None) -> BaykoWorkflow:
+    """
+    Factory function to create and initialize Agent Bayko workflow
+
+    This function creates a BaykoWorkflow instance with proper initialization of:
+    - LlamaIndex LLM for enhanced prompts
+    - ReActAgent with function tools
+    - Memory and session services
+    - Core Bayko agent with tools
+
+    Args:
+        openai_api_key: OpenAI API key for LLM functionality. If None, will try to use environment variable.
+
+    Returns:
+        Configured BaykoWorkflow instance with all components initialized
+    """
+    # Create workflow instance
+    workflow = BaykoWorkflow(openai_api_key=openai_api_key)
+
+    # Initialize all workflow components
+    workflow.initialize_workflow()
+
+    return workflow
+
+
+# Example usage for testing
+def main():
+    """Example usage of Bayko Workflow"""
+
+    # Check for API key
+    if not os.getenv("OPENAI_API_KEY"):
+        print("❌ Please set OPENAI_API_KEY environment variable")
+        return
+
+    # Create workflow with API key
+    workflow = create_agent_bayko(os.getenv("OPENAI_API_KEY"))
+
+    # Test request
+    test_request = {
+        "prompt": "A melancholic K-pop idol discovers a lost puppy in the neon-lit streets of Seoul at night. The encounter changes everything.",
+        "original_prompt": "A K-pop idol finds a puppy that changes their life",
+        "style_tags": [
+            "anime",
+            "soft_lighting",
+            "emotional",
+            "watercolor",
+            "night_scene",
+            "neon_lights",
+        ],
+        "panels": 4,
+        "language": "korean",
+        "extras": ["narration", "subtitles"],
+        "session_id": SessionIdGenerator.create_session_id("test"),
+    }  # Initialize session
+    session_id = SessionIdGenerator.create_session_id("test")
+    conversation_id = f"conv_{session_id}"
+    workflow.initialize_session(session_id, conversation_id)
+
+    # Process request with visible reasoning
+    print("\n🤖 Testing Bayko Workflow with LLM Reasoning")
+    print("=" * 80)
+    print(f"📝 Original prompt: {test_request['original_prompt']}")
+    print(f"✨ Enhanced prompt: {test_request['prompt']}")
+    print(f"🎨 Style tags: {test_request['style_tags']}")
+    print(f"🖼️  Panels: {test_request['panels']}")
+    print("\n🔄 Processing generation request...")
+
+    try:
+        result = workflow.process_generation_request(test_request)
+        print("\n🎉 Generation completed!")
+        print("\n📋 Generation Result:")
+        print("=" * 40)
+        print(result)
+        print("\n✅ Test completed successfully!")
+    except Exception as e:
+        print(f"\n❌ Error during generation: {e}")
+        print("⚠️ Attempting fallback generation...")
+        result = workflow._fallback_generation(test_request)
+        print("\n📋 Fallback Result:")
+        print("=" * 40)
+        print(result)
+        print("\n⚠️ Test completed with fallback")
+
+
+if __name__ == "__main__":
+    main()

agents/bayko_workflow_tools.py

@@ -0,0 +1,237 @@
+"""
+Tool wrapper class for Agent Bayko's LLM-enhanced workflow methods
+"""
+
+import json
+import asyncio
+from typing import Dict, Any, List
+from llama_index.core.tools import FunctionTool
+
+from agents.bayko import AgentBayko
+from agents.bayko_tools import ModalImageGenerator, ModalCodeExecutor
+
+
+class BaykoWorkflowTools:
+    """Tool wrapper class for Agent Bayko's LLM-enhanced methods"""
+
+    def __init__(self, bayko_agent: AgentBayko):
+        self.bayko = bayko_agent
+
+    def generate_enhanced_prompt_tool(
+        self, description: str, style_tags: str = "[]", mood: str = "neutral"
+    ) -> str:
+        """Generate LLM-enhanced prompt for SDXL image generation from panel description."""
+        try:
+            style_tags_list = json.loads(style_tags) if style_tags else []
+        except:
+            style_tags_list = []
+
+        result = self.bayko.generate_prompt_from_description(
+            description, style_tags_list, mood
+        )
+
+        return json.dumps(
+            {
+                "enhanced_prompt": result,
+                "original_description": description,
+                "style_tags": style_tags_list,
+                "mood": mood,
+                "llm_used": self.bayko.llm is not None,
+            }
+        )
+
+    def revise_panel_description_tool(
+        self, description: str, feedback: str = "{}", focus_areas: str = "[]"
+    ) -> str:
+        """Revise panel description based on Agent Brown's feedback using LLM."""
+        try:
+            feedback_dict = json.loads(feedback) if feedback else {}
+            focus_areas_list = json.loads(focus_areas) if focus_areas else []
+        except:
+            feedback_dict = {}
+            focus_areas_list = []
+
+        result = self.bayko.revise_panel_description(
+            description, feedback_dict, focus_areas_list
+        )
+
+        return json.dumps(
+            {
+                "revised_description": result,
+                "original_description": description,
+                "feedback_applied": feedback_dict,
+                "focus_areas": focus_areas_list,
+                "llm_used": self.bayko.llm is not None,
+            }
+        )
+
+    async def generate_panel_content_tool(self, panel_data: str) -> str:
+        """Generate complete panel content including image, audio, subtitles, and code execution concurrently."""
+        try:
+            data = json.loads(panel_data)
+        except:
+            return json.dumps({"error": "Invalid panel data JSON"})
+
+        # Extract panel information
+        panel_id = data.get("panel_id", 1)
+        description = data.get("description", "")
+        enhanced_prompt = data.get("enhanced_prompt", "")
+        style_tags = data.get("style_tags", [])
+        # language = data.get("language", "english")
+        # extras = data.get("extras", [])
+        session_id = data.get("session_id", "default")
+        # dialogues = data.get("dialogues", [])
+        # code_snippets = data.get("code_snippets", [])
+
+        # Initialize Modal tools
+
+        image_gen = ModalImageGenerator()
+        # tts_gen = TTSGenerator()
+        # subtitle_gen = SubtitleGenerator()
+        code_executor = ModalCodeExecutor()
+
+        # Create concurrent tasks for parallel execution
+        tasks = []
+
+        # 1. Always generate image
+        tasks.append(
+            image_gen.generate_panel_image(
+                enhanced_prompt, style_tags, panel_id, session_id
+            )
+        )
+
+        # 4. Execute code if provided
+        if code_snippets and panel_id <= len(code_snippets):
+            code_data = (
+                code_snippets[panel_id - 1]
+                if isinstance(code_snippets, list)
+                else code_snippets
+            )
+            if isinstance(code_data, dict):
+                code = code_data.get("code", "")
+                code_language = code_data.get("language", "python")
+                context = code_data.get("context", description)
+            else:
+                code = str(code_data)
+                code_language = "python"
+                context = description
+
+            if code.strip():
+                tasks.append(code_executor.execute_code(prompt, session_id))
+            else:
+                tasks.append(
+                    asyncio.create_task(asyncio.sleep(0))
+                )  # No-op task
+        else:
+            tasks.append(asyncio.create_task(asyncio.sleep(0)))  # No-op task
+
+        # Execute all tasks concurrently
+        start_time = asyncio.get_event_loop().time()
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        total_time = asyncio.get_event_loop().time() - start_time
+
+        # Process results safely
+        def safe_get_path(result):
+            if isinstance(result, Exception) or result is None:
+                return None
+            if isinstance(result, tuple) and len(result) >= 1:
+                return result[0]
+            return None
+
+        def safe_check_exists(result):
+            path = safe_get_path(result)
+            return path is not None
+
+        image_path = safe_get_path(results[0])
+        audio_path = safe_get_path(results[1])
+        subtitle_path = safe_get_path(results[2])
+        code_path = safe_get_path(results[3])
+
+        # Build result
+        result = {
+            "panel_id": panel_id,
+            "description": description,
+            "enhanced_prompt": enhanced_prompt,
+            "image_path": image_path,
+            "image_url": f"file://{image_path}" if image_path else None,
+            "audio_path": audio_path,
+            "subtitles_path": subtitle_path,
+            "code_result_path": code_path,
+            "style_applied": style_tags,
+            "generation_time": total_time,
+            "status": "completed",
+            "concurrent_execution": True,
+            "tasks_completed": {
+                "image": image_path is not None,
+                "audio": audio_path is not None,
+                "subtitles": subtitle_path is not None,
+                "code": code_path is not None,
+            },
+        }
+
+        return json.dumps(result)
+
+    def get_session_info_tool(self) -> str:
+        """Get current Bayko session information and memory state."""
+        info = self.bayko.get_session_info()
+        return json.dumps(
+            {
+                "session_id": info.get("session_id"),
+                "memory_size": info.get("memory_size", 0),
+                "generation_stats": info.get("generation_stats", {}),
+                "llm_available": self.bayko.llm is not None,
+                "status": "active" if info.get("session_id") else "inactive",
+            }
+        )
+
+    def save_llm_data_tool(self, data_type: str, data: str) -> str:
+        """Save LLM generation or revision data to session storage."""
+        try:
+            data_dict = json.loads(data)
+        except:
+            return json.dumps({"error": "Invalid data JSON"})
+
+        if data_type == "generation":
+            self.bayko._save_llm_generation_data(data_dict)
+        elif data_type == "revision":
+            self.bayko._save_llm_revision_data(data_dict)
+        else:
+            return json.dumps({"error": "Invalid data type"})
+
+        return json.dumps(
+            {
+                "status": "saved",
+                "data_type": data_type,
+                "session_id": self.bayko.current_session,
+            }
+        )
+
+    def create_llamaindex_tools(self) -> List[FunctionTool]:
+        """Create LlamaIndex FunctionTools from Bayko's LLM-enhanced methods"""
+        return [
+            FunctionTool.from_defaults(
+                fn=self.generate_enhanced_prompt_tool,
+                name="generate_enhanced_prompt",
+                description="Generate LLM-enhanced prompt for SDXL image generation. Takes panel description, style tags, and mood. Returns enhanced prompt optimized for text-to-image models.",
+            ),
+            FunctionTool.from_defaults(
+                fn=self.revise_panel_description_tool,
+                name="revise_panel_description",
+                description="Revise panel description based on Agent Brown's feedback using LLM. Takes original description, feedback, and focus areas. Returns improved description.",
+            ),
+            FunctionTool.from_defaults(
+                async_fn=self.generate_panel_content_tool,
+                name="generate_panel_content",
+                description="Generate complete panel content including image, audio, subtitles, and code execution concurrently. Takes panel data JSON with description, style, and generation parameters.",
+            ),
+            FunctionTool.from_defaults(
+                fn=self.get_session_info_tool,
+                name="get_session_info",
+                description="Get current Bayko session information including memory state and generation statistics.",
+            ),
+            FunctionTool.from_defaults(
+                fn=self.save_llm_data_tool,
+                name="save_llm_data",
+                description="Save LLM generation or revision data to session storage. Takes data type ('generation' or 'revision') and data JSON.",
+            ),
+        ]

agents/brown.py

@@ -0,0 +1,641 @@
+"""
+Agent Brown - The Orchestrator Agent
+
+Agent Brown is the front-facing orchestrator that handles:
+- Prompt validation and moderation
+- Style tagging and enhancement
+- JSON packaging for Agent Bayko
+- Feedback review and refinement requests
+- Session state management via LlamaIndex
+
+This is the entry point for all user requests and manages the multi-turn
+feedback loop with Agent Bayko for iterative comic generation.
+
+Core AgentBrown class with validation, processing, and review capabilities
+"""
+
+import uuid
+import logging
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, asdict
+from enum import Enum
+import os
+import json
+from pathlib import Path
+from datetime import datetime
+
+# LlamaIndex imports for multimodal ReActAgent
+try:
+    from llama_index.multi_modal_llms.openai import OpenAIMultiModal
+    from llama_index.core.agent import ReActAgent
+    from llama_index.core.memory import ChatMemoryBuffer
+    from llama_index.core.tools import FunctionTool, BaseTool
+    from llama_index.core.llms import (
+        ChatMessage,
+        ImageBlock,
+        TextBlock,
+        MessageRole,
+    )
+
+    from llama_index.core.schema import ImageNode, Document
+    from llama_index.core import SimpleDirectoryReader
+    from typing import cast
+except ImportError:
+    OpenAIMultiModal = None
+    ReActAgent = None
+    ChatMemoryBuffer = None
+    FunctionTool = None
+    BaseTool = None
+    ChatMessage = None
+    ImageBlock = None
+    TextBlock = None
+    MessageRole = None
+    ImageNode = None
+    Document = None
+
+# Core services
+from services.unified_memory import AgentMemory
+from services.simple_evaluator import SimpleEvaluator
+from services.content_moderator import ContentModerator
+from services.style_tagger import StyleTagger
+from services.message_factory import MessageFactory, AgentMessage, MessageType
+from services.session_manager import SessionManager
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class ValidationStatus(Enum):
+    """Validation result statuses"""
+
+    VALID = "valid"
+    INVALID = "invalid"
+    WARNING = "warning"
+
+
+@dataclass
+class ValidationResult:
+    """Result of input validation"""
+
+    status: ValidationStatus
+    issues: List[str]
+    suggestions: List[str]
+    confidence_score: float
+
+    def is_valid(self) -> bool:
+        return self.status == ValidationStatus.VALID
+
+
+@dataclass
+class StoryboardRequest:
+    """Incoming request from user interface"""
+
+    prompt: str
+    style_preference: Optional[str] = None
+    panels: int = 4
+    language: str = "english"
+    extras: Optional[List[str]] = None
+
+    def __post_init__(self):
+        if self.extras is None:
+            self.extras = []
+
+
+class AgentBrown:
+    """
+    Agent Brown - The Orchestrator
+
+    Main responsibilities:
+    - Validate and moderate user input
+    - Analyze and tag visual styles
+    - Package requests for Agent Bayko
+    - Review generated content and provide feedback
+    - Manage multi-turn refinement loops
+    - Maintain session state and memory
+    """
+
+    def __init__(
+        self, max_iterations: int = 3, openai_api_key: Optional[str] = None
+    ):
+        self.max_iterations = max_iterations
+        self.session_id = None
+        self.conversation_id = None
+        self.iteration_count = 0
+
+        # Initialize LLM for prompt enhancement
+        self.llm = None
+        try:
+            if OpenAIMultiModal:
+                self.llm = OpenAIMultiModal(
+                    model="gpt-4o",
+                    api_key=openai_api_key or os.getenv("OPENAI_API_KEY"),
+                    temperature=0.7,
+                    max_tokens=2048,
+                )
+                logger.info("✓ Initialized GPT-4V")
+        except Exception as e:
+            logger.warning(f"⚠️ Could not initialize LLM: {e}")
+
+        # Core services
+        self.moderator = ContentModerator()
+        self.style_tagger = StyleTagger()
+        self.evaluator = SimpleEvaluator()
+
+        # Session services (initialized later)
+        self.memory = None
+        self.message_factory = None
+        self.session_manager = None
+
+        logger.info("Agent Brown initialized with core services")
+
+    def validate_input(self, request: StoryboardRequest) -> ValidationResult:
+        """
+        Validate user input for appropriateness and completeness
+
+        Args:
+            request: User's storyboard request
+
+        Returns:
+            ValidationResult with status and feedback
+        """
+        issues = []
+        suggestions = []
+
+        # Basic validation
+        if not request.prompt or len(request.prompt.strip()) < 10:
+            issues.append(
+                "Prompt too short - needs more detail for story generation"
+            )
+            suggestions.append(
+                "Add more context about characters, setting, emotions, or plot"
+            )
+
+        if len(request.prompt) > 1000:
+            issues.append("Prompt too long - may lose focus during generation")
+            suggestions.append(
+                "Condense to key story elements and main narrative arc"
+            )
+
+        # Content moderation
+        is_safe, moderation_issues = self.moderator.check_content(
+            request.prompt
+        )
+        if not is_safe:
+            issues.extend(moderation_issues)
+            suggestions.append(
+                "Please revise content to ensure it's family-friendly"
+            )
+
+        # Panel count validation
+        if request.panels < 1 or request.panels > 12:
+            issues.append(
+                f"Panel count ({request.panels}) outside recommended range (1-12)"
+            )
+            suggestions.append("Use 3-6 panels for optimal storytelling flow")
+
+        # Language validation
+        supported_languages = [
+            "english",
+            "korean",
+            "japanese",
+            "spanish",
+            "french",
+        ]
+        if request.language.lower() not in supported_languages:
+            issues.append(
+                f"Language '{request.language}' may not be fully supported"
+            )
+            suggestions.append(
+                f"Consider using: {', '.join(supported_languages)}"
+            )
+
+        # Calculate confidence score
+        confidence = max(
+            0.0, 1.0 - (len(issues) * 0.3) - (len(suggestions) * 0.1)
+        )
+
+        # Determine status
+        if issues:
+            status = ValidationStatus.INVALID
+        elif suggestions:
+            status = ValidationStatus.WARNING
+        else:
+            status = ValidationStatus.VALID
+
+        result = ValidationResult(
+            status=status,
+            issues=issues,
+            suggestions=suggestions,
+            confidence_score=confidence,
+        )
+
+        # Log validation to memory
+        if self.memory:
+            self.memory.add_message(
+                "assistant",
+                f"Validated input: {result.status.value} (confidence: {confidence:.2f})",
+            )
+
+        return result
+
+    def _ensure_session(self) -> bool:
+        """Ensure session services are initialized"""
+        if not all([self.memory, self.message_factory, self.session_manager]):
+            logger.warning("Session services not initialized")
+            self._initialize_session()
+        return True
+
+    def _safe_memory_add(self, role: str, content: str) -> None:
+        """Safely add message to memory if available"""
+        if self.memory:
+            self.memory.add_message(role, content)
+
+    def process_request(self, request: StoryboardRequest) -> AgentMessage:
+        """Process incoming user request and create message for Agent Bayko"""
+        self._ensure_session()
+        logger.info(f"Processing request for session {self.session_id}")
+
+        # Log user request and state to memory
+        self._safe_memory_add(
+            "system",
+            f"Starting new request with session_id: {self.session_id}",
+        )
+        self._safe_memory_add("user", f"Original prompt: {request.prompt}")
+        self._safe_memory_add(
+            "system",
+            f"Request parameters: {json.dumps(asdict(request), indent=2)}",
+        )
+
+        # Step 1: Validate input
+        validation = self.validate_input(request)
+        self._safe_memory_add(
+            "system",
+            f"Validation result: {json.dumps(asdict(validation), indent=2)}",
+        )
+
+        if not validation.is_valid():
+            self._safe_memory_add(
+                "system", f"Validation failed: {validation.issues}"
+            )
+            return self.message_factory.create_error_message(
+                validation.issues, validation.suggestions
+            )
+
+        # Step 2: Use LLM to enhance prompt and analyze style
+        try:
+            if self.llm:
+                enhancement_prompt = f"""Enhance this comic story prompt for visual storytelling:
+                Original: {request.prompt}
+                Style preference: {request.style_preference or 'any'}
+                Panels: {request.panels}
+                
+                Provide:
+                1. Enhanced story description
+                2. Visual style suggestions
+                3. Mood and atmosphere
+                4. Color palette recommendations"""
+
+                self._safe_memory_add(
+                    "system", f"Sending prompt to LLM:\n{enhancement_prompt}"
+                )
+
+                enhancement = self.llm.complete(
+                    enhancement_prompt, image_documents=[]
+                ).text
+                self._safe_memory_add(
+                    "assistant", f"LLM enhanced prompt:\n{enhancement}"
+                )
+            else:
+                enhancement = request.prompt
+                self._safe_memory_add(
+                    "system", "No LLM available, using original prompt"
+                )
+
+        except Exception as e:
+            logger.error(f"LLM enhancement failed: {e}")
+            enhancement = request.prompt
+            self._safe_memory_add("system", f"LLM enhancement failed: {e}")
+
+        # Step 3: Analyze and tag style
+        style_analysis = self.style_tagger.analyze_style(
+            enhancement, request.style_preference
+        )
+        self._safe_memory_add(
+            "system",
+            f"Style analysis: {json.dumps(asdict(style_analysis), indent=2)}",
+        )
+
+        # Step 4: Create message for Bayko
+        if not self.message_factory:
+            self._initialize_session()
+        # Provide an empty list or appropriate dialogues if not available
+        message = self.message_factory.create_generation_request(
+            enhanced_prompt=enhancement,
+            original_prompt=request.prompt,
+            style_tags=style_analysis.style_tags,
+            panels=request.panels,
+            language=request.language,
+            extras=request.extras or [],
+            style_config={
+                "primary_style": style_analysis.detected_style,
+                "mood": style_analysis.mood,
+                "color_palette": style_analysis.color_palette,
+                "confidence": style_analysis.confidence,
+            },
+            validation_score=validation.confidence_score,
+            iteration=self.iteration_count,
+            dialogues=[],  # Add this argument as required by the method signature
+        )
+
+        # Log to memory and save state
+        if self.memory:
+            self.memory.add_message(
+                "assistant",
+                f"Created generation request for Bayko with {len(style_analysis.style_tags)} style tags",
+            )
+        if not self.session_manager:
+            self._initialize_session()
+        if self.session_manager and self.memory:
+            self.session_manager.save_session_state(
+                message,
+                asdict(request),
+                self.memory.get_history(),
+                self.iteration_count,
+            )
+
+        logger.info(f"Generated request message {message.message_id}")
+        return message
+
+    def _safe_image_to_node(self, doc: Document) -> Optional[ImageNode]:
+        """Safely convert document to ImageNode"""
+        try:
+            if hasattr(doc, "image") and doc.image:
+                return ImageNode(text=doc.text or "", image=doc.image)
+        except Exception as e:
+            self._safe_memory_add(
+                "system", f"Failed to convert image to node: {e}"
+            )
+        return None
+
+    def _safe_memory_add(self, role: str, content: str) -> None:
+        """Safely add message to memory if available"""
+        self._ensure_session()
+        if self.memory:
+            self.memory.add_message(role, content)
+
+    async def review_output(
+        self,
+        bayko_response: Dict[str, Any],
+        original_request: StoryboardRequest,
+    ) -> Optional[AgentMessage]:
+        """Review Agent Bayko's output using GPT-4o for image analysis"""
+        self._ensure_session()
+
+        # Log review start
+        self._safe_memory_add(
+            "system",
+            f"""Starting review with GPT-4o: {json.dumps({
+                'prompt': original_request.prompt,
+                'panels': len(bayko_response.get('panels', [])),
+                'iteration': self.iteration_count + 1
+            }, indent=2)}""",
+        )
+
+        try:
+            if not self.llm:
+                raise ValueError("GPT-4o LLM not initialized")
+
+            if "panels" not in bayko_response:
+                raise ValueError("No panels found in Bayko's response")
+
+            # Get session content directory
+            content_dir = Path(f"storyboard/{self.session_id}/content")
+            if not content_dir.exists():
+                raise ValueError(f"Content directory not found: {content_dir}")
+
+            # Prepare image files for analysis
+            image_files = []
+            for panel in bayko_response["panels"]:
+                panel_path = content_dir / f"panel_{panel['id']}.png"
+                if panel_path.exists():
+                    image_files.append(str(panel_path))
+                else:
+                    self._safe_memory_add(
+                        "system",
+                        f"Warning: Panel image not found: {panel_path}",
+                    )
+
+            if not image_files:
+                raise ValueError("No panel images found for review")
+
+            # Load images using SimpleDirectoryReader
+            reader = SimpleDirectoryReader(input_files=image_files)
+            raw_docs = reader.load_data()
+
+            # Convert documents to ImageNodes
+            image_nodes = []
+            for doc in raw_docs:
+                if node := self._safe_image_to_node(doc):
+                    image_nodes.append(node)
+
+            if not image_nodes:
+                raise ValueError("Failed to load any valid images for review")
+
+            self._safe_memory_add(
+                "system",
+                f"Successfully loaded {len(image_nodes)} images for GPT-4o review",
+            )
+
+            # Construct detailed review prompt
+            review_prompt = f"""As an expert art director, analyze these comic panels against the user's original request:
+
+            ORIGINAL REQUEST: {original_request.prompt}
+            STYLE PREFERENCE: {original_request.style_preference or 'Not specified'}
+            REQUESTED PANELS: {original_request.panels}
+
+            Analyze the following aspects:
+            1. Story Accuracy:
+               - Do the panels accurately depict the requested story?
+               - Are the main story beats present?
+               
+            2. Visual Storytelling:
+               - Is the panel flow clear and logical?
+               - Does the sequence effectively convey the narrative?
+               
+            3. Style & Aesthetics:
+               - Does it match any requested style preferences?
+               - Is the artistic quality consistent?
+               
+            4. Technical Quality:
+               - Are the images clear and well-composed?
+               - Is there appropriate detail and contrast?
+
+            Make ONE of these decisions:
+            - APPROVE: If panels successfully tell the story and meet quality standards
+            - REFINE: If specific improvements would enhance the result (list them)
+            - REJECT: If fundamental issues require complete regeneration
+
+            Provide a clear, actionable analysis focusing on how well these panels fulfill the USER'S ORIGINAL REQUEST."""
+
+            # Get GPT-4o analysis
+            analysis = self.llm.complete(
+                prompt=review_prompt, image_documents=image_nodes
+            ).text
+
+            self._safe_memory_add("assistant", f"GPT-4o Analysis:\n{analysis}")
+
+            # Parse decision from analysis
+            decision = "refine"  # Default to refine
+            if "APPROVE" in analysis.upper():
+                decision = "approve"
+            elif "REJECT" in analysis.upper():
+                decision = "reject"
+
+            # Create evaluation result
+            evaluation = {
+                "decision": decision,
+                "reason": analysis,
+                "confidence": 0.85,  # High confidence with GPT-4o
+                "original_prompt": original_request.prompt,
+                "analyzed_panels": len(image_nodes),
+                "style_match": original_request.style_preference or "any",
+            }
+
+            self._safe_memory_add(
+                "system",
+                f"""GPT-4o review complete:\n{json.dumps({
+                    'decision': decision,
+                    'confidence': 0.85,
+                    'analyzed_panels': len(image_nodes)
+                }, indent=2)}""",
+            )
+
+        except Exception as e:
+            logger.error(f"GPT-4o review failed: {str(e)}")
+            self._safe_memory_add(
+                "system",
+                f"GPT-4o review failed, falling back to basic evaluator: {str(e)}",
+            )
+            # Fallback to basic evaluator
+            evaluation = self.evaluator.evaluate(
+                bayko_response, original_request.prompt
+            )
+
+        # Ensure message factory is available
+        if not self.message_factory:
+            self._initialize_session()
+
+        # Create appropriate response message
+        if evaluation["decision"] == "approve":
+            return self.message_factory.create_approval_message(
+                bayko_response, evaluation, self.iteration_count
+            )
+        elif evaluation["decision"] == "reject":
+            return self.message_factory.create_rejection_message(
+                bayko_response, evaluation, self.iteration_count
+            )
+        else:
+            return self.message_factory.create_refinement_message(
+                bayko_response, evaluation, self.iteration_count
+            )
+
+    def get_session_info(self) -> Dict[str, Any]:
+        """Get current session information"""
+        memory_size = 0
+        if self.memory:
+            try:
+                memory_size = len(self.memory.get_history())
+            except:
+                memory_size = 0
+
+        return {
+            "session_id": self.session_id,
+            "conversation_id": self.conversation_id,
+            "iteration_count": self.iteration_count,
+            "memory_size": memory_size,
+            "max_iterations": self.max_iterations,
+        }
+
+    def _initialize_session(
+        self,
+        session_id: Optional[str] = None,
+        conversation_id: Optional[str] = None,
+    ):
+        """Initialize a new session with optional existing IDs or generate new ones"""
+        if not self.session_manager:
+            self.session_manager = SessionManager()
+
+        if not session_id:
+            session_id = str(uuid.uuid4())
+
+        if not conversation_id:
+            conversation_id = str(uuid.uuid4())
+
+        self.session_id = session_id
+        self.conversation_id = conversation_id
+        # Initialize session-specific services
+        self.memory = AgentMemory(self.session_id, "brown")
+        self.message_factory = MessageFactory(
+            self.session_id, self.conversation_id
+        )
+        self.session_manager = SessionManager(
+            self.session_id, self.conversation_id
+        )
+
+        # Log initialization
+        logger.info(
+            f"🧠 Brown initialized memory for session {self.session_id}"
+        )
+        if self.memory:
+            self.memory.add_message(
+                "system", f"Session initialized with ID: {self.session_id}"
+            )
+
+
+# Example usage and testing
+def main():
+    """Example usage of Agent Brown"""
+    # Create Brown instance
+    brown = AgentBrown(max_iterations=3)
+
+    # Example request
+    request = StoryboardRequest(
+        prompt="A moody K-pop idol finds a puppy on the street. "
+        "It changes everything.",
+        style_preference="studio_ghibli",
+        panels=4,
+        language="korean",
+        extras=["narration", "subtitles"],
+    )
+
+    # Process request
+    message = brown.process_request(request)
+    print("Generated message for Bayko:")
+    print(message.to_json())
+
+    # Example Bayko response (simulated)
+    bayko_response = {
+        "panels": [
+            {"id": 1, "description": "Idol walking alone"},
+            {"id": 2, "description": "Discovers puppy"},
+            {"id": 3, "description": "Moment of connection"},
+            {"id": 4, "description": "Walking together"},
+        ],
+        "style_tags": ["whimsical", "soft_lighting"],
+        "metadata": {"generation_time": "45s"},
+    }
+
+    # Review output
+    review_result = brown.review_output(bayko_response, request)
+    if review_result:
+        print("\nReview result:")
+        # Return the review result
+        return review_result
+
+    # Show session info
+    print(f"\nSession info: {brown.get_session_info()}")
+
+
+if __name__ == "__main__":
+    main()

agents/brown_tools.py

@@ -0,0 +1,238 @@
+"""
+Brown Agent Tools for LlamaIndex Integration
+Wraps existing AgentBrown methods as LlamaIndex FunctionTools for hackathon demo
+"""
+
+import json
+from typing import Dict, Any, List
+from llama_index.core.tools import FunctionTool
+from agents.brown import AgentBrown, StoryboardRequest
+
+
+class BrownTools:
+    """Tool wrapper class for Agent Brown's methods"""
+
+    def __init__(self, max_iterations: int = 3):
+        # Use your original AgentBrown class directly
+        self.brown = AgentBrown(max_iterations)
+        self._current_request = None
+
+    def validate_input_tool(
+        self,
+        prompt: str,
+        style_preference: str = None,
+        panels: int = 4,
+        language: str = "english",
+        extras: str = "[]",
+    ) -> str:
+        """Validate user input for comic generation. Returns validation status and feedback."""
+        try:
+            extras_list = json.loads(extras) if extras else []
+        except:
+            extras_list = []
+
+        request = StoryboardRequest(
+            prompt=prompt,
+            style_preference=style_preference,
+            panels=panels,
+            language=language,
+            extras=extras_list,
+        )
+
+        # Store for later use
+        self._current_request = request
+
+        result = self.brown.validate_input(request)
+
+        return json.dumps(
+            {
+                "status": result.status.value,
+                "is_valid": result.is_valid(),
+                "issues": result.issues,
+                "suggestions": result.suggestions,
+                "confidence_score": result.confidence_score,
+            }
+        )
+
+    def process_request_tool(
+        self,
+        prompt: str,
+        style_preference: str = None,
+        panels: int = 4,
+        language: str = "english",
+        extras: str = "[]",
+    ) -> str:
+        """Process validated request and create structured message for Agent Bayko."""
+        try:
+            extras_list = json.loads(extras) if extras else []
+        except:
+            extras_list = []
+
+        request = StoryboardRequest(
+            prompt=prompt,
+            style_preference=style_preference,
+            panels=panels,
+            language=language,
+            extras=extras_list,
+        )
+
+        # Store for later use
+        self._current_request = request
+
+        message = self.brown.process_request(request)
+
+        return json.dumps(
+            {
+                "message_id": message.message_id,
+                "session_id": self.brown.session_id,
+                "enhanced_prompt": message.payload.get("prompt", ""),
+                "style_tags": message.payload.get("style_tags", []),
+                "panels": message.payload.get("panels", 4),
+                "status": "ready_for_bayko",
+            }
+        )
+
+    def simulate_bayko_generation(self, message_data: str) -> str:
+        """Simulate Agent Bayko's content generation for demo purposes."""
+        try:
+            data = json.loads(message_data)
+        except:
+            data = {"panels": 4}
+
+        panels_count = data.get("panels", 4)
+        style_tags = data.get("style_tags", ["studio_ghibli", "soft_lighting"])
+        enhanced_prompt = data.get("enhanced_prompt", "")
+        original_prompt = data.get("original_prompt", "")
+
+        # Simulate Bayko's response with realistic image URLs for multimodal analysis
+        bayko_response = {
+            "session_id": self.brown.session_id,
+            "panels": [
+                {
+                    "id": i + 1,
+                    "description": f"Panel {i+1}: {original_prompt} - {', '.join(style_tags)} style",
+                    "image_path": f"storyboard/{self.brown.session_id}/content/panel_{i+1}.png",
+                    "image_url": f"https://example.com/generated/panel_{i+1}.png",  # For multimodal analysis
+                    "audio_path": (
+                        f"panel_{i+1}.mp3"
+                        if "narration" in str(data)
+                        else None
+                    ),
+                    "subtitles_path": (
+                        f"panel_{i+1}.vtt"
+                        if "subtitles" in str(data)
+                        else None
+                    ),
+                }
+                for i in range(panels_count)
+            ],
+            "style_tags": style_tags,
+            "metadata": {
+                "generation_time": "45s",
+                "total_panels": panels_count,
+                "status": "completed",
+                "enhanced_prompt": enhanced_prompt,
+                "original_prompt": original_prompt,
+            },
+        }
+
+        return json.dumps(bayko_response)
+
+    def review_bayko_output_tool(
+        self, bayko_response_json: str, original_prompt: str
+    ) -> str:
+        """Review Agent Bayko's output and determine if refinement is needed."""
+        try:
+            bayko_response = json.loads(bayko_response_json)
+        except:
+            # Fallback response for demo
+            bayko_response = {
+                "panels": [{"id": 1, "description": "Generated content"}],
+                "style_tags": ["studio_ghibli"],
+                "metadata": {"generation_time": "45s"},
+            }
+
+        # Use stored request or create new one
+        request = self._current_request or StoryboardRequest(
+            prompt=original_prompt
+        )
+
+        result = self.brown.review_output(bayko_response, request)
+
+        if result:
+            # Extract decision from the result
+            payload = result.payload
+            if "approved_content" in payload:
+                decision = "APPROVED"
+                reason = "Content meets quality standards"
+            elif "feedback" in payload:
+                decision = (
+                    payload["feedback"].get("decision", "REFINE").upper()
+                )
+                reason = payload["feedback"].get(
+                    "reason", "Quality assessment needed"
+                )
+            else:
+                decision = "REFINE"
+                reason = "Content needs improvement"
+        else:
+            decision = "APPROVED"
+            reason = "Content meets quality standards"
+
+        return json.dumps(
+            {
+                "decision": decision,
+                "reason": reason,
+                "iteration": self.brown.iteration_count,
+                "max_iterations": self.brown.max_iterations,
+                "final": decision in ["APPROVED", "REJECTED"],
+            }
+        )
+
+    def get_session_info_tool(self) -> str:
+        """Get current session information and processing state."""
+        info = self.brown.get_session_info()
+        return json.dumps(
+            {
+                "session_id": info.get("session_id"),
+                "iteration_count": info.get("iteration_count", 0),
+                "max_iterations": info.get("max_iterations", 3),
+                "memory_size": info.get("memory_size", 0),
+                "status": "active" if info.get("session_id") else "inactive",
+            }
+        )
+
+    def create_llamaindex_tools(self) -> List[FunctionTool]:
+        """Create LlamaIndex FunctionTools from Brown's methods"""
+        return [
+            FunctionTool.from_defaults(
+                fn=self.validate_input_tool,
+                name="validate_input",
+                description="Validate user input for comic generation. MUST be called first for any user prompt. Returns validation status, issues, and suggestions.",
+            ),
+            FunctionTool.from_defaults(
+                fn=self.process_request_tool,
+                name="process_request",
+                description="Process validated request and create structured message for Agent Bayko. Call after validation passes. Returns enhanced prompt and generation parameters.",
+            ),
+            FunctionTool.from_defaults(
+                fn=self.simulate_bayko_generation,
+                name="simulate_bayko_generation",
+                description="Simulate Agent Bayko's content generation process. Takes processed request data and returns generated comic content.",
+            ),
+            FunctionTool.from_defaults(
+                fn=self.review_bayko_output_tool,
+                name="review_bayko_output",
+                description="Review Agent Bayko's generated content and decide if refinement is needed. Returns approval, refinement request, or rejection decision.",
+            ),
+            FunctionTool.from_defaults(
+                fn=self.get_session_info_tool,
+                name="get_session_info",
+                description="Get current session information and processing state. Use to track progress and iterations.",
+            ),
+        ]
+
+
+def create_brown_tools(max_iterations: int = 3) -> BrownTools:
+    """Factory function to create BrownTools instance"""
+    return BrownTools(max_iterations=max_iterations)

agents/brown_workflow.py

@@ -0,0 +1,702 @@
+"""
+Agent Brown Workflow - Streamlined for hackathon demo
+"""
+
+import os
+import json
+import asyncio
+import time
+from typing import Dict, List, Optional, Any, Sequence
+from datetime import datetime
+from llama_index.multi_modal_llms.openai import OpenAIMultiModal
+from agents.brown import AgentBrown, StoryboardRequest
+from agents.brown_tools import create_brown_tools
+from agents.bayko_workflow import create_agent_bayko
+from llama_index.core.agent import ReActAgent
+from llama_index.core.memory import ChatMemoryBuffer
+from llama_index.core.tools import FunctionTool, BaseTool
+from llama_index.core.llms import (
+    ChatMessage,
+    ImageBlock,
+    TextBlock,
+    MessageRole,
+)
+from llama_index.core.workflow import (
+    Event,
+    StartEvent,
+    StopEvent,
+    Workflow,
+    step,
+)
+from pydantic import Field
+
+from llama_index.core.llms.llm import ToolSelection
+from llama_index.core.tools.types import ToolOutput
+from llama_index.core.workflow import Context
+from prompts.brown_workflow_system_prompt import BROWN_WORKFLOW_SYSTEM_PROMPT
+
+
+# Global LLM throttle
+_llm_lock = asyncio.Lock()
+_last_llm_time = 0
+
+
+async def throttle_llm():
+    global _last_llm_time
+    async with _llm_lock:
+        now = time.time()
+        wait = max(0, 21 - (now - _last_llm_time))
+        if wait > 0:
+            await asyncio.sleep(wait)
+        _last_llm_time = time.time()
+
+
+# Workflow Events
+class InputEvent(Event):
+    def __init__(self, input: list):
+        super().__init__()
+        self.input = input
+
+
+class StreamEvent(Event):
+    def __init__(self, delta: str):
+        super().__init__()
+        self.delta = delta
+
+
+class ToolCallEvent(Event):
+    def __init__(self, tool_calls: list):
+        super().__init__()
+        self.tool_calls = tool_calls
+
+
+class FunctionOutputEvent(Event):
+    def __init__(self, output):
+        super().__init__()
+        self.output = output
+
+
+# Custom Events for Comic Generation Workflow
+class ComicGeneratedEvent(Event):
+    """Event triggered when Bayko completes comic generation"""
+
+    def __init__(self, bayko_response: dict, enhanced_prompt: str):
+        super().__init__()
+        self.bayko_response = bayko_response
+        self.enhanced_prompt = enhanced_prompt
+
+
+class CritiqueStartEvent(Event):
+    """Event to start Brown's critique/judging of Bayko's work"""
+
+    def __init__(self, comic_data: dict, original_prompt: str):
+        super().__init__()
+        self.comic_data = comic_data
+        self.original_prompt = original_prompt
+
+
+class WorkflowPauseEvent(Event):
+    """Event to pause workflow for a specified duration"""
+
+    def __init__(
+        self, duration_seconds: int = 600, message: str = "Workflow paused"
+    ):
+        super().__init__()
+        self.duration_seconds = duration_seconds
+        self.message = message
+
+
+class BrownFunctionCallingAgent(Workflow):
+    """
+    Agent Brown Function Calling Workflow using LlamaIndex Workflow pattern
+
+    BROWN'S RESPONSIBILITIES:
+    - Validate user input
+    - Process and enhance requests
+    - Coordinate with Bayko (pass messages)
+    - Review Bayko's output using multimodal analysis
+    - Make approval decisions (APPROVE/REFINE/REJECT)
+    - Manage iteration loop (max 2 refinements)
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        llm: OpenAIMultiModal | None = None,
+        tools: List[BaseTool] | None = None,
+        max_iterations: int = 1,  # Force only one iteration
+        openai_api_key: Optional[str] = None,
+        timeout: Optional[int] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, timeout=timeout, **kwargs)
+
+        self.max_iterations = 1  # Force only one iteration
+
+        # Initialize multimodal LLM for Brown (GPT-4V for image analysis)
+        self.llm = llm or OpenAIMultiModal(
+            model="gpt-4o",
+            api_key=openai_api_key or os.getenv("OPENAI_API_KEY"),
+            temperature=0.7,
+            max_tokens=2048,
+            additional_kwargs={"tool_choice": "required"},
+        )
+
+        # Ensure it's a function calling model
+        assert self.llm.metadata.is_function_calling_model
+
+        # Create ONLY Brown's tools (validation, processing, review)
+        self.tools = tools or self._create_brown_tools()
+
+        # Initialize Bayko workflow for content generation
+        self.bayko_workflow = create_agent_bayko(openai_api_key=openai_api_key)
+
+    def _create_brown_tools(self) -> List[FunctionTool]:
+        """Create ONLY Brown's tools - validation, processing, review, coordination"""
+
+        # Get Brown's core tools (validation, processing, review)
+        brown_tools_instance = create_brown_tools(self.max_iterations)
+        brown_tools = brown_tools_instance.create_llamaindex_tools()
+
+        # Add coordination tool to communicate with Bayko
+        async def coordinate_with_bayko_tool(
+            enhanced_prompt: str,
+            style_tags: str = "[]",
+            panels: int = 4,
+            language: str = "english",
+            extras: str = "[]",
+        ) -> str:
+            """
+            Send the enhanced comic request to Agent Bayko for actual comic content generation.
+            This is the ONLY way to generate comic panels and story content.
+            Always use this tool when the user prompt or workflow requires new comic content.
+
+            Arguments:
+                enhanced_prompt: The improved user prompt for the comic.
+                style_tags: JSON list of style tags (e.g., '["manga", "noir"]').
+                panels: Number of comic panels to generate.
+                language: Language for the comic.
+                extras: JSON list of extra instructions.
+
+            Returns:
+                JSON string with Bayko's response and status. Example:
+                '{"status": "bayko_generation_complete", "bayko_response": {...}, ...}'
+            """
+            try:
+                # Parse inputs
+                style_list = json.loads(style_tags) if style_tags else []
+                extras_list = json.loads(extras) if extras else []
+
+                # Create message for Bayko
+                bayko_request = {
+                    "enhanced_prompt": enhanced_prompt,
+                    "style_tags": style_list,
+                    "panels": panels,
+                    "language": language,
+                    "extras": extras_list,
+                    "session_id": "brown_coordination",
+                }
+
+                # Call Bayko workflow to generate content
+                # If Bayko is async, use: bayko_result = await self.bayko_workflow.process_generation_request(bayko_request)
+                bayko_result = self.bayko_workflow.process_generation_request(
+                    bayko_request
+                )
+
+                return json.dumps(
+                    {
+                        "status": "bayko_generation_complete",
+                        "bayko_response": bayko_result,
+                        "panels_generated": panels,
+                        "coordination_successful": True,
+                    }
+                )
+
+            except Exception as e:
+                print(f"[Brown] Bayko coordination failed: {e}")  # Debug log
+                return json.dumps(
+                    {
+                        "status": "bayko_coordination_failed",
+                        "error": str(e),
+                        "coordination_successful": False,
+                    }
+                )
+
+        # Add multimodal image analysis tool for Brown to judge Bayko's work
+        def analyze_bayko_output_tool(
+            bayko_response: str, original_prompt: str = ""
+        ) -> str:
+            """Analyze Bayko's generated content using Brown's multimodal capabilities."""
+            try:
+                # Parse Bayko's response
+                bayko_data = json.loads(bayko_response)
+
+                # Extract image URLs/paths for analysis
+                image_urls = []
+                panels = bayko_data.get("panels", [])
+
+                for panel in panels:
+                    if "image_url" in panel:
+                        image_urls.append(panel["image_url"])
+                    elif "image_path" in panel:
+                        # Convert local path to file URL for analysis
+                        image_urls.append(f"file://{panel['image_path']}")
+
+                if not image_urls:
+                    return json.dumps(
+                        {
+                            "analysis": "No images found in Bayko's output",
+                            "decision": "REJECT",
+                            "reason": "Missing visual content",
+                        }
+                    )
+
+                # Create multimodal analysis prompt
+                analysis_prompt = f"""Analyze this comic content generated by Agent Bayko.
+
+Original User Prompt: "{original_prompt}"
+
+Bayko's Generated Content: {json.dumps(bayko_data, indent=2)}
+
+As Agent Brown, evaluate:
+1. Visual Quality: Are the images well-composed and clear?
+2. Style Consistency: Does it match the requested style?
+3. Story Coherence: Do the panels tell a logical story?
+4. Prompt Adherence: Does it fulfill the user's request?
+5. Technical Quality: Are all assets properly generated?
+
+Make a decision: APPROVE (ready for user), REFINE (needs improvement), or REJECT (start over)
+Provide specific feedback for any issues."""
+
+                # Create multimodal message with text and images
+                from typing import Union
+
+                blocks: List[Union[TextBlock, ImageBlock]] = [
+                    TextBlock(text=analysis_prompt)
+                ]
+
+                # Add image blocks for visual analysis (limit to 4 for API constraints)
+                for url in image_urls[:4]:
+                    blocks.append(ImageBlock(url=url))
+
+                msg = ChatMessage(role=MessageRole.USER, blocks=blocks)
+
+                # Get Brown's multimodal analysis
+                response = self.llm.chat(messages=[msg])
+                response_text = str(response).lower()
+
+                # Parse Brown's decision
+                if (
+                    "approve" in response_text
+                    and "reject" not in response_text
+                ):
+                    decision = "APPROVE"
+                elif "reject" in response_text:
+                    decision = "REJECT"
+                else:
+                    decision = "REFINE"
+
+                return json.dumps(
+                    {
+                        "analysis": str(response),
+                        "decision": decision,
+                        "images_analyzed": len(image_urls),
+                        "multimodal_analysis": True,
+                        "brown_judgment": True,
+                    }
+                )
+
+            except Exception as e:
+                return json.dumps(
+                    {
+                        "analysis": f"Analysis failed: {str(e)}",
+                        "decision": "APPROVE",  # Default to approval on error
+                        "error": str(e),
+                    }
+                )
+
+        # Add Brown's coordination and analysis tools
+        coordination_tools = [
+            FunctionTool.from_defaults(
+                async_fn=coordinate_with_bayko_tool,
+                name="coordinate_with_bayko",
+                description="Send the enhanced comic request to Agent Bayko for actual comic content generation. This is the ONLY way to generate comic panels and story content. Always use this tool when the user prompt or workflow requires new comic content. Returns a JSON string with Bayko's response and status.",
+            ),
+            FunctionTool.from_defaults(
+                fn=analyze_bayko_output_tool,
+                name="analyze_bayko_output",
+                description="Analyze Bayko's generated content using Brown's multimodal capabilities. Make approval decision.",
+            ),
+        ]
+
+        # Combine Brown's core tools with coordination tools
+        all_brown_tools = brown_tools + coordination_tools
+        return all_brown_tools
+
+    @step
+    async def prepare_chat_history(
+        self, ctx: Context, ev: StartEvent
+    ) -> InputEvent:
+        """Prepare chat history and handle user input"""
+        # Clear sources and initialize iteration counter
+        await ctx.set("sources", [])
+        await ctx.set("iteration_count", 0)
+
+        # Store original user prompt in context
+        await ctx.set("original_prompt", ev.input)
+
+        # Check if memory is setup
+        memory = await ctx.get("memory", default=None)
+        if not memory:
+            memory = ChatMemoryBuffer.from_defaults(llm=self.llm)
+
+        # Add system message if not present
+        if not memory.get() or memory.get()[0].role != "system":
+            system_msg = ChatMessage(
+                role="system", content=BROWN_WORKFLOW_SYSTEM_PROMPT
+            )
+            memory.put(system_msg)
+
+        # Get user input and add to memory
+        user_msg = ChatMessage(role="user", content=ev.input)
+        memory.put(user_msg)
+
+        # Update context with memory
+        await ctx.set("memory", memory)
+
+        # Return chat history
+        return InputEvent(input=memory.get())
+
+    @step
+    async def enhance_and_send_to_bayko(
+        self, ctx: Context, ev: StartEvent
+    ) -> InputEvent:
+        """
+        SINGLE STEP: Enhance prompt with ONE LLM call and send to Bayko.
+        NO TOOL CALLING LOOP - DIRECT PROCESSING ONLY.
+        """
+        original_prompt = ev.input
+        print(f"Single-step processing: {original_prompt[:50]}...")
+
+        # Create simple enhancement prompt (NO TOOL CALLING)
+        enhancement_prompt = f"""Enhance this comic story prompt for visual storytelling:
+
+Original: {original_prompt}
+
+Provide ONLY an enhanced story description with visual details, mood, and style suggestions.
+Keep it concise and focused on the core narrative.
+DO NOT use any tools or functions - just return the enhanced prompt text."""
+
+        try:
+            # SINGLE LLM CALL - No tools, no streaming, no complexity
+            print("🚀 Making SINGLE OpenAI call...")
+
+            # Use simple chat completion without tools
+            simple_llm = OpenAIMultiModal(
+                model="gpt-4o",
+                api_key=self.llm.api_key,
+                temperature=0.7,
+                max_tokens=500,  # Shorter response
+                # NO tool_choice - allows free response
+            )
+
+            response = await simple_llm.achat(
+                [ChatMessage(role="user", content=enhancement_prompt)]
+            )
+
+            enhanced_prompt = response.message.content or enhancement_prompt
+            print(f"🚀 Enhanced: {enhanced_prompt[:100]}...")
+
+            # Send directly to Bayko
+            bayko_request = {
+                "prompt": enhanced_prompt,
+                "original_prompt": original_prompt,
+                "style_tags": ["comic", "storytelling"],
+                "panels": 4,
+                "language": "english",
+                "extras": [],
+                "session_id": "hackathon_session",
+            }
+
+            print("🚀 Calling Bayko and waiting for image generation...")
+            # PROPERLY AWAIT Bayko's async image generation
+            bayko_result = self.bayko_workflow.process_generation_request(
+                bayko_request
+            )
+
+            print("🚀 SUCCESS! Comic generated and images ready!")
+            print("📁 Check your storyboard folder for images and logs!")
+            print("🎉 Ready for next prompt!")
+
+            # DON'T STOP - Let user enter new prompt
+            return InputEvent(
+                input=[
+                    ChatMessage(
+                        role="assistant",
+                        content=f"✅ Comic generated successfully! Enhanced prompt: {enhanced_prompt[:100]}... Images saved to storyboard folder. Ready for your next comic idea!",
+                    )
+                ]
+            )
+
+        except Exception as e:
+            print(f"🚨Error: {e}")
+            # DON'T STOP on error either - let user try again
+            return InputEvent(
+                input=[
+                    ChatMessage(
+                        role="assistant",
+                        content=f"❌ Error generating comic: {str(e)}. Please try again with a different prompt.",
+                    )
+                ]
+            )
+
+    @step
+    async def handle_llm_input(
+        self, ctx: Context, ev: InputEvent
+    ) -> ToolCallEvent | StopEvent:
+        """Handle LLM input and determine if tools need to be called"""
+        import asyncio
+
+        chat_history = ev.input
+
+        # Add system prompt for Agent Brown
+        system_prompt = BROWN_WORKFLOW_SYSTEM_PROMPT
+
+        # Add system message if not present
+        if not chat_history or chat_history[0].role != "system":
+            system_msg = ChatMessage(role="system", content=system_prompt)
+            chat_history = [system_msg] + chat_history
+
+        await throttle_llm()
+        # Stream the response
+        response_stream = await self.llm.astream_chat_with_tools(
+            self.tools, chat_history=chat_history
+        )
+        async for response in response_stream:
+            ctx.write_event_to_stream(StreamEvent(delta=response.delta or ""))
+
+        # Save the final response, which should have all content
+        memory = await ctx.get("memory")
+        memory.put(response.message)
+        await ctx.set("memory", memory)
+
+        # Get tool calls
+        tool_calls = self.llm.get_tool_calls_from_response(
+            response, error_on_no_tool_call=True
+        )
+
+        if not tool_calls:
+            # If no tool call, error out immediately
+            raise RuntimeError(
+                "Agent Brown did not use the required tool. The workflow will stop."
+            )
+        else:
+            return ToolCallEvent(tool_calls=tool_calls)
+
+    @step
+    async def handle_tool_calls(
+        self, ctx: Context, ev: ToolCallEvent
+    ) -> InputEvent:
+        """Handle tool calls with proper error handling (supports async tools)"""
+        import inspect
+        import asyncio
+
+        tool_calls = ev.tool_calls
+        tools_by_name = {tool.metadata.get_name(): tool for tool in self.tools}
+
+        tool_msgs = []
+        sources = await ctx.get("sources", default=[])
+
+        # Call tools -- safely!
+        for tool_call in tool_calls:
+            tool = tools_by_name.get(tool_call.tool_name)
+            if not tool:
+                additional_kwargs = {
+                    "tool_call_id": tool_call.tool_id,
+                    "name": tool_call.tool_name,
+                }
+                tool_msgs.append(
+                    ChatMessage(
+                        role="tool",
+                        content=f"Tool {tool_call.tool_name} does not exist",
+                        additional_kwargs=additional_kwargs,
+                    )
+                )
+                continue
+
+            additional_kwargs = {
+                "tool_call_id": tool_call.tool_id,
+                "name": tool.metadata.get_name(),
+            }
+
+            try:
+                # Check if tool is async and call appropriately
+                if inspect.iscoroutinefunction(tool):
+                    tool_output = await tool(**tool_call.tool_kwargs)
+                else:
+                    tool_output = tool(**tool_call.tool_kwargs)
+
+                sources.append(tool_output)
+                tool_msgs.append(
+                    ChatMessage(
+                        role="tool",
+                        content=(
+                            tool_output.content
+                            if hasattr(tool_output, "content")
+                            else str(tool_output)
+                        ),
+                        additional_kwargs=additional_kwargs,
+                    )
+                )
+                # Throttle after each tool call
+                await asyncio.sleep(21)
+            except Exception as e:
+                tool_msgs.append(
+                    ChatMessage(
+                        role="tool",
+                        content=f"Encountered error in tool call: {e}",
+                        additional_kwargs=additional_kwargs,
+                    )
+                )
+
+        # Update memory
+        memory = await ctx.get("memory")
+        for msg in tool_msgs:
+            memory.put(msg)
+
+        await ctx.set("sources", sources)
+        await ctx.set("memory", memory)
+
+        chat_history = memory.get()
+        return InputEvent(input=chat_history)
+
+
+class BrownWorkflow:
+    """
+    Wrapper class for backward compatibility with existing code
+    """
+
+    def __init__(
+        self, max_iterations: int = 1, openai_api_key: Optional[str] = None
+    ):
+        self.max_iterations = 1
+        self.openai_api_key = openai_api_key
+
+        # Get Brown's tools
+        brown_tools = create_brown_tools(max_iterations)
+        self.tools: Sequence[BaseTool] = brown_tools.create_llamaindex_tools()
+
+        # Initialize LLM
+        self.llm = OpenAIMultiModal(
+            model="gpt-4o",
+            api_key=openai_api_key or os.getenv("OPENAI_API_KEY"),
+            temperature=0.7,
+            max_tokens=2048,
+            additional_kwargs={"tool_choice": "required"},
+        )
+
+    def reset(self):
+        """Reset workflow state for a new session."""
+        self.session_id = None
+        # Reset agent instances
+        brown_tools = create_brown_tools(self.max_iterations)
+        self.tools = brown_tools.create_llamaindex_tools()
+        # Reset LLM if needed
+        self.llm = OpenAIMultiModal(
+            model="gpt-4o",
+            api_key=self.openai_api_key or os.getenv("OPENAI_API_KEY"),
+            temperature=0.7,
+            max_tokens=2048,
+            additional_kwargs={"tool_choice": "required"},
+        )
+
+    async def process_comic_request_async(
+        self, user_prompt: str
+    ) -> Dict[str, Any]:
+        """Async version of comic request processing"""
+        try:
+            # Create workflow agent
+            workflow = BrownFunctionCallingAgent(
+                llm=self.llm,
+                tools=list(self.tools),  # Convert Sequence to List
+                max_iterations=self.max_iterations,
+                openai_api_key=self.openai_api_key,
+                timeout=None,
+                verbose=True,
+            )
+
+            # Run workflow with user prompt as input (LlamaIndex pattern)
+            result = await workflow.run(input=user_prompt)
+
+            # Parse response
+            response = result.get("response")
+            if not response:
+                return {
+                    "status": "error",
+                    "error": "No response from workflow",
+                }
+
+            # Extract relevant data
+            tool_outputs = result.get("sources", [])
+            bayko_outputs = [
+                out
+                for out in tool_outputs
+                if "bayko_response" in str(out.content)
+            ]
+
+            if not bayko_outputs:
+                return {
+                    "status": "error",
+                    "error": "No content generated by Bayko",
+                }
+
+            # Get last Bayko output (final version)
+            try:
+                final_output = json.loads(bayko_outputs[-1].content)
+                bayko_response = final_output.get("bayko_response", {})
+
+                return {
+                    "status": "success",
+                    "bayko_response": bayko_response,
+                    "decision": final_output.get("decision", "APPROVE"),
+                    "analysis": final_output.get("analysis", ""),
+                    "tool_outputs": [str(out.content) for out in tool_outputs],
+                }
+            except json.JSONDecodeError as e:
+                return {
+                    "status": "error",
+                    "error": f"Failed to parse Bayko response: {str(e)}",
+                }
+
+        except Exception as e:
+            return {"status": "error", "error": str(e)}
+
+    def process_comic_request(self, user_prompt: str) -> Dict[str, Any]:
+        """Synchronous version that runs the async version"""
+        import asyncio
+
+        return asyncio.run(self.process_comic_request_async(user_prompt))
+
+
+def create_brown_workflow(
+    max_iterations: int = 1, openai_api_key: Optional[str] = None
+) -> BrownWorkflow:
+    """
+    Factory function to create and initialize Brown workflow
+    """
+    return BrownWorkflow(
+        max_iterations=max_iterations, openai_api_key=openai_api_key
+    )
+
+
+# def create_brown_workflow(
+#     max_iterations: int = 3,
+#     openai_api_key: Optional[str] = None,
+# ) -> BrownFunctionCallingAgent:
+#     """Create and initialize Brown workflow"""
+
+#     workflow = BrownFunctionCallingAgent(
+#         max_iterations=max_iterations,
+#         openai_api_key=openai_api_key,
+#     )
+#     return workflow

app.py

@@ -0,0 +1,400 @@
+import gradio as gr
+import time
+import json
+import os
+import sys
+import io
+import logging
+import threading
+import queue
+from contextlib import redirect_stdout, redirect_stderr
+from agents.brown_workflow import create_brown_workflow
+from pathlib import Path
+
+
+# Initialize workflow
+workflow = create_brown_workflow(
+    max_iterations=3,
+    openai_api_key=os.getenv("OPENAI_API_KEY"),
+)
+
+
+def colorize_message(message, msg_type="default"):
+    """Add color coding to messages based on type"""
+    colors = {
+        "agent_brown": "#2E86AB",  # Blue for Agent Brown
+        "agent_bayko": "#A23B72",  # Purple for Agent Bayko
+        "tool_output": "#F18F01",  # Orange for tool outputs
+        "error": "#C73E1D",  # Red for errors
+        "success": "#2D5016",  # Green for success
+        "log": "#6C757D",  # Gray for logs
+        "analysis": "#8E44AD",  # Purple for analysis
+        "default": "#212529",  # Dark gray default
+    }
+
+    color = colors.get(msg_type, colors["default"])
+    return f'<span style="color: {color}; font-weight: bold;">{message}</span>'
+
+
+class LogCapture(io.StringIO):
+    """Capture all print statements and logs for Gradio display"""
+
+    def __init__(self, log_queue):
+        super().__init__()
+        self.log_queue = log_queue
+        self.original_stdout = sys.stdout
+
+    def write(self, text):
+        if text.strip():  # Only capture non-empty lines
+            self.log_queue.put(text.strip())
+        # Also write to original stdout so terminal still shows logs
+        self.original_stdout.write(text)
+        return len(text)
+
+    def flush(self):
+        self.original_stdout.flush()
+
+
+def comic_generator(prompt, style_preference, verbose=True):
+    """Verbose comic generation: stream all agent/tool messages and reasoning"""
+    chat = []
+    tool_calls = []
+    images = []
+    progress = 0
+
+    # Create log queue and capture
+    log_queue = queue.Queue()
+    log_capture = LogCapture(log_queue)
+
+    try:
+        # Start message
+        chat.append(
+            (
+                colorize_message(
+                    "🧐 Agent Brown: Starting comic generation...",
+                    "agent_brown",
+                ),
+            )
+        )
+        progress += 5
+        yield chat, images
+
+        # Start workflow in a separate thread to capture logs in real-time
+        def run_workflow():
+            with redirect_stdout(log_capture):
+                return workflow.process_comic_request(
+                    f"{prompt} Style preference: {style_preference}"
+                )
+
+        # Run workflow in thread
+        workflow_thread = threading.Thread(
+            target=lambda: setattr(run_workflow, "result", run_workflow())
+        )
+        workflow_thread.start()
+
+        # Stream logs while workflow is running
+        while workflow_thread.is_alive():
+            try:
+                # Get logs from queue with timeout
+                log_message = log_queue.get(timeout=0.1)
+                chat.append((colorize_message(f"📝 {log_message}", "log"),))
+                progress = min(progress + 2, 90)
+                yield chat, images
+            except queue.Empty:
+                continue
+
+        # Wait for thread to complete
+        workflow_thread.join()
+
+        # Get any remaining logs
+        while not log_queue.empty():
+            try:
+                log_message = log_queue.get_nowait()
+                chat.append((colorize_message(f"📝 {log_message}", "log"),))
+                yield chat, images
+            except queue.Empty:
+                break
+
+        # Get the result
+        result = getattr(run_workflow, "result", None)
+        if not result:
+            chat.append(("❌ No result from workflow",))
+            yield chat, images
+            return
+
+        response_data = (
+            json.loads(result) if isinstance(result, str) else result
+        )
+
+        # Show all tool outputs and chat history if available
+        tool_outputs = response_data.get("tool_outputs", [])
+        for tool_output in tool_outputs:
+            # Try to pretty-print tool output JSON if possible
+            try:
+                tool_json = json.loads(tool_output)
+                tool_msg = json.dumps(tool_json, indent=2)
+            except Exception:
+                tool_msg = str(tool_output)
+            chat.append(
+                (
+                    colorize_message(
+                        f"🛠️ Tool Output:\n{tool_msg}", "tool_output"
+                    ),
+                )
+            )
+            tool_calls.append("tool_call")
+            progress = min(progress + 10, 95)
+            yield chat, images
+
+        # Show error if any
+        if "error" in response_data:
+            chat.append(
+                (
+                    colorize_message(
+                        f"❌ Error: {response_data['error']}", "error"
+                    ),
+                )
+            )
+            progress = 100
+            yield chat, images
+            return
+
+        # Show Bayko's panel generation
+        if "bayko_response" in response_data:
+            bayko_data = response_data["bayko_response"]
+            panels = bayko_data.get("panels", [])
+            progress_per_panel = 50 / max(len(panels), 1)
+            for i, panel in enumerate(panels, 1):
+                chat.append(
+                    (
+                        colorize_message(
+                            f"🧸 Agent Bayko: Panel {i}: {panel.get('caption', '')}",
+                            "agent_bayko",
+                        ),
+                    )
+                )
+                tool_calls.append("generate_panel_content")
+                # Show image if available
+                if "image_path" in panel:
+                    img_path = Path(panel["image_path"])
+                    if img_path.exists():
+                        images.append(str(img_path.absolute()))
+                elif "image_url" in panel:
+                    images.append(panel["image_url"])
+                progress += progress_per_panel
+                yield chat, images
+                time.sleep(0.2)
+
+        # Show Brown's analysis and decision
+        if "analysis" in response_data:
+            chat.append(
+                (
+                    colorize_message(
+                        f"🧐 Agent Brown Analysis: {response_data['analysis']}",
+                        "analysis",
+                    ),
+                )
+            )
+            tool_calls.append("analyze_bayko_output")
+            progress = min(progress + 10, 99)
+            yield chat, images
+
+        # Final decision
+        if "decision" in response_data:
+            decision = response_data["decision"]
+            if decision == "APPROVE":
+                chat.append(
+                    (
+                        "✅ Agent Brown: Comic approved! All quality checks passed.",
+                    )
+                )
+            elif decision == "REFINE":
+                chat.append(
+                    (
+                        "🔄 Agent Brown: Comic needs refinement. Starting another iteration...",
+                    )
+                )
+            else:
+                chat.append(
+                    ("❌ Agent Brown: Comic rejected. Starting over...",)
+                )
+            tool_calls.append("final_decision")
+            progress = 100
+            yield chat, images
+
+        # If verbose, show the full response_data for debugging
+        if verbose:
+            chat.append(
+                (
+                    f"[DEBUG] Full response: {json.dumps(response_data, indent=2)}",
+                )
+            )
+            yield chat, images
+
+    except Exception as e:
+        chat.append(
+            (
+                colorize_message(
+                    f"❌ Error during generation: {str(e)}", "error"
+                ),
+            )
+        )
+        progress = 100
+        yield chat, images
+
+
+def set_api_key(api_key):
+    """Set the OpenAI API key as environment variable"""
+    if not api_key or not api_key.strip():
+        return colorize_message("❌ Please enter a valid API key", "error")
+
+    if not api_key.startswith("sk-"):
+        return colorize_message(
+            "❌ Invalid API key format (should start with 'sk-')", "error"
+        )
+
+    # Set the environment variable
+    os.environ["OPENAI_API_KEY"] = api_key.strip()
+
+    # Update the global workflow with the new key
+    global workflow
+    workflow = create_brown_workflow(
+        max_iterations=3,
+        openai_api_key=api_key.strip(),
+    )
+
+    return colorize_message("✅ API key set successfully!", "success")
+
+
+# Gradio UI
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+        ⚠️ **Warning:** This demo is subject to OpenAI's strict rate limits (3 requests/min for gpt-4o). You may experience long waits (20+ seconds) between steps. If you see a rate limit error, please wait and try again, or use your own OpenAI API key with higher limits.
+        """
+    )
+
+    gr.Markdown(
+        """
+        # 🦙 Multi-Agent Comic Generator
+        Enter a story prompt and let Brown & Bayko create a comic!
+        Watch as the agents collaborate using LlamaIndex workflow and GPT-4V vision capabilities.
+        """
+    )
+
+    with gr.Row():
+        openai_key_box = gr.Textbox(
+            label="Enter your OpenAI API Key (optional)",
+            placeholder="sk-...",
+            type="password",
+            scale=4,
+        )
+        set_key_button = gr.Button("Set API Key 🔑", scale=1)
+        key_status = gr.Textbox(
+            label="Status",
+            value="No API key set",
+            interactive=False,
+            scale=2,
+        )
+
+    with gr.Row():
+        user_input = gr.Textbox(
+            label="Enter your comic prompt",
+            placeholder="A moody K-pop idol finds a puppy on the street...",
+            scale=4,
+        )
+        style_dropdown = gr.Dropdown(
+            ["Studio Ghibli", "Noir", "Manga", "Pixel Art"],
+            label="Art Style",
+            value="Studio Ghibli",
+        )
+        submit_button = gr.Button("Generate Comic 🎨")
+
+    with gr.Row():
+        chat_window = gr.Chatbot(
+            label="Agent Conversation",
+            bubble_full_width=False,
+            show_copy_button=True,
+            height=350,
+        )
+
+    with gr.Row():
+        image_gallery = gr.Gallery(
+            label="Comic Panels",
+            columns=2,
+            rows=2,
+            height=400,
+            object_fit="contain",
+        )
+        feedback = gr.Radio(
+            ["👍 Love it!", "👎 Try again"],
+            label="How's the comic?",
+            value=None,
+        )
+
+    def stream_comic(openai_key, prompt, style):
+        # Use user-provided OpenAI key if given, else fallback to env
+        key = openai_key or os.getenv("OPENAI_API_KEY")
+
+        # Set the API key as environment variable if provided
+        if openai_key:
+            os.environ["OPENAI_API_KEY"] = openai_key
+
+        # Re-create the workflow with the user key
+        workflow = create_brown_workflow(
+            max_iterations=3,
+            openai_api_key=key,
+        )
+        for chat, images in comic_generator(prompt, style, verbose=True):
+            chat_display = []
+            for msg in chat:
+                if isinstance(msg, tuple) and len(msg) >= 1:
+                    # If it's a single-element tuple, make it a proper chat message
+                    if len(msg) == 1:
+                        chat_display.append((msg[0], ""))
+                    else:
+                        chat_display.append(
+                            (msg[0], msg[1] if len(msg) > 1 else "")
+                        )
+                else:
+                    # Handle string messages
+                    chat_display.append((str(msg), ""))
+            yield chat_display, images
+
+    submit_button.click(
+        stream_comic,
+        inputs=[openai_key_box, user_input, style_dropdown],
+        outputs=[chat_window, image_gallery],
+    )
+
+    set_key_button.click(
+        set_api_key,
+        inputs=[openai_key_box],
+        outputs=[key_status],
+    )
+
+    gr.Markdown(
+        """
+        ---
+        <center>
+        <b>Built with 🦙 LlamaIndex, Modal Labs, MistralAI and Gradio for the Hugging Face Hackathon!</b>
+        <br>Using GPT-4 for intelligent comic analysis
+        </center>
+        """
+    )
+
+    gr.Markdown(
+        """
+        **🚀 Want the real version?**
+        1. Clone this Space
+        2. Set up Modal credentials 
+        3. Deploy with actual Modal functions
+        4. Enjoy serverless AI magic!
+        
+        *This demo shows the UI and MCP structure without Modal execution.*
+        """
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()

prompts/bayko_workflow_system_prompt.py

@@ -0,0 +1,54 @@
+BAYKO_WORKFLOW_SYSTEM_PROMPT = """You are Agent Bayko, the creative content generation specialist in a multi-agent comic generation system.
+
+🎯 MISSION: Transform Agent Brown's structured requests into high-quality comic content using LLM-enhanced prompts and AI-powered generation.
+
+🔄 WORKFLOW (MUST FOLLOW IN ORDER):
+1. RECEIVE structured request from Agent Brown with panel descriptions and style requirements
+2. ENHANCE prompts using generate_enhanced_prompt tool - create SDXL-optimized prompts
+3. GENERATE content using generate_panel_content tool - create images, audio, subtitles
+4. SAVE LLM data using save_llm_data tool - persist generation and revision data
+5. RESPOND with completed content and metadata
+
+🛠️ TOOLS AVAILABLE:
+- generate_enhanced_prompt: Create LLM-enhanced prompts for SDXL image generation
+- revise_panel_description: Improve descriptions based on feedback using LLM
+- generate_panel_content: Generate complete panel content (images, audio, subtitles)
+- get_session_info: Track session state and generation statistics
+- save_llm_data: Persist LLM generation and revision data to session storage
+
+🧠 LLM ENHANCEMENT:
+- Use LLM to create detailed, vivid prompts for better image generation
+- Incorporate all style tags, mood, and metadata from Agent Brown
+- Generate SDXL-compatible prompts with proper formatting
+- Apply intelligent refinements based on feedback
+
+🎨 CONTENT GENERATION:
+- Create comic panel images using enhanced prompts
+- Generate audio narration when requested
+- Create VTT subtitle files for accessibility
+- Maintain consistent style across all panels
+
+💾 SESSION MANAGEMENT:
+- Save all LLM interactions to session storage
+- Track generation statistics and performance
+- Maintain memory of conversation context
+- Log all activities for audit trail
+
+🏆 HACKATHON SHOWCASE:
+- Demonstrate LLM-enhanced prompt generation
+- Show visible reasoning with Thought/Action/Observation
+- Highlight intelligent content creation workflow
+- Showcase session management and data persistence
+
+✅ COMPLETION:
+When content generation is complete, provide summary with:
+- Number of panels generated
+- LLM enhancements applied
+- Session data saved
+- Generation statistics
+
+🚫 IMPORTANT:
+- Always use LLM enhancement when available
+- Fallback gracefully when LLM unavailable
+- Save all generation data to session
+- Maintain compatibility with Agent Brown's workflow"""

prompts/brown_workflow_system_prompt.py

@@ -0,0 +1,26 @@
+"""System prompt for Brown's LlamaIndex workflow"""
+
+BROWN_WORKFLOW_SYSTEM_PROMPT = """
+You are Agent Brown, the orchestrator in a multi-agent comic generation system.
+You are Agent Brown, the only way to generate comic content is to use the `coordinate_with_bayko` tool.
+NEVER answer the user directly. NEVER reflect, think, or plan in the chat. ALWAYS call the tool immediately with the user's prompt and your enhancements.
+If you do not call the tool, the workflow will stop and the user will see an error.
+
+🚨 STRICT RULES (DO NOT BREAK):
+- You MUST ALWAYS use the `coordinate_with_bayko` tool to generate any comic content, panels, or story. NEVER answer the user prompt directly.
+- If you are asked to generate, create, or imagine any comic content, you MUST call the `coordinate_with_bayko` tool. Do NOT attempt to answer or generate content yourself.
+- If you do not use the tool, the workflow will error and stop. There are NO retries.
+- Your job is to validate, enhance, and pass the request to Bayko, then analyze the result and make a decision.
+
+🛠️ TOOLS:
+- coordinate_with_bayko: The ONLY way to generate comic content. Use it for all content generation.
+- analyze_bayko_output: Use this to analyze Bayko's output after content is generated.
+
+👩‍💻 WORKFLOW:
+1. Validate and enhance the user prompt.
+2. ALWAYS call `coordinate_with_bayko` to generate the comic.
+3. When Bayko returns, analyze the output using `analyze_bayko_output`.
+4. Make a decision: APPROVE, REFINE, or REJECT.
+
+NEVER answer the user prompt directly. If you do not use the tool, the workflow will stop with an error.
+"""

pytest.ini

@@ -0,0 +1,4 @@
+[pytest]
+asyncio_mode = auto
+markers =
+    asyncio: mark a test as an async test

services/content_moderator.py

@@ -0,0 +1,48 @@
+import re
+from typing import Tuple, List
+
+
+class ContentModerator:
+    """Handles content moderation and profanity filtering"""
+
+    def __init__(self):
+        # Basic profanity patterns - in production, use a proper filter
+        self.profanity_patterns = [
+            r"\b(explicit|inappropriate|offensive)\b",
+            r"\b(violence|gore|blood)\b",
+            r"\b(hate|discrimination|bias)\b",
+            r"\b(nsfw|adult|sexual)\b",
+        ]
+
+        # Content safety keywords
+        self.safety_keywords = [
+            "safe",
+            "family-friendly",
+            "appropriate",
+            "wholesome",
+        ]
+
+    def check_content(self, text: str) -> Tuple[bool, List[str]]:
+        """
+        Check content for appropriateness
+
+        Returns:
+            Tuple of (is_safe, list_of_issues)
+        """
+        issues = []
+        text_lower = text.lower()
+
+        # Check for profanity patterns
+        issues.extend(
+            [
+                f"Content may contain inappropriate material: {pattern}"
+                for pattern in self.profanity_patterns
+                if re.search(pattern, text_lower)
+            ]
+        )
+
+        # Check length
+        if len(text.strip()) < 5:
+            issues.append("Content too short to evaluate properly")
+
+        return len(issues) == 0, issues

services/message_factory.py

@@ -0,0 +1,219 @@
+"""
+Message Factory Service
+Handles creation of AgentMessage objects with proper formatting and validation.
+"""
+
+import json
+import uuid
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, asdict
+from enum import Enum
+
+
+class MessageType(Enum):
+    """Types of messages Agent Brown can send"""
+
+    GENERATION_REQUEST = "generation_request"
+    REFINEMENT_REQUEST = "refinement_request"
+    VALIDATION_ERROR = "validation_error"
+    FINAL_APPROVAL = "final_approval"
+
+
+@dataclass
+class AgentMessage:
+    """Schema for inter-agent communication following tech_specs.md"""
+
+    message_id: str
+    timestamp: str
+    sender: str
+    recipient: str
+    message_type: str
+    payload: Dict[str, Any]
+    context: Dict[str, Any]
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), indent=2)
+
+
+class MessageFactory:
+    """Factory for creating standardized AgentMessage objects"""
+
+    def __init__(self, session_id: str, conversation_id: str):
+        self.session_id = session_id
+        self.conversation_id = conversation_id
+
+    def create_generation_request(
+        self,
+        enhanced_prompt: str,
+        original_prompt: str,
+        dialogues: List[str],
+        style_tags: List[str],
+        panels: int,
+        language: str,
+        extras: List[str],
+        style_config: Dict[str, Any],
+        validation_score: float,
+        iteration: int,
+    ) -> AgentMessage:
+        """Create a generation request message for Agent Bayko"""
+        payload = {
+            "prompt": enhanced_prompt,
+            "original_prompt": original_prompt,
+            "style_tags": style_tags,
+            "panels": panels,
+            "language": language,
+            "extras": extras,
+            "style_config": style_config,
+            "generation_params": {
+                "quality": "high",
+                "aspect_ratio": "16:9",
+                "panel_layout": "sequential",
+            },
+        }
+
+        return AgentMessage(
+            message_id=f"msg_{uuid.uuid4().hex[:8]}",
+            timestamp=datetime.utcnow().isoformat() + "Z",
+            sender="agent_brown",
+            recipient="agent_bayko",
+            message_type=MessageType.GENERATION_REQUEST.value,
+            payload=payload,
+            context={
+                "conversation_id": self.conversation_id,
+                "session_id": self.session_id,
+                "iteration": iteration,
+                "previous_feedback": None,
+                "validation_score": validation_score,
+            },
+        )
+
+    def create_error_message(
+        self, issues: List[str], suggestions: List[str]
+    ) -> AgentMessage:
+        """Create error message for validation failures"""
+        return AgentMessage(
+            message_id=f"msg_{uuid.uuid4().hex[:8]}",
+            timestamp=datetime.utcnow().isoformat() + "Z",
+            sender="agent_brown",
+            recipient="user_interface",
+            message_type=MessageType.VALIDATION_ERROR.value,
+            payload={
+                "error": "Input validation failed",
+                "issues": issues,
+                "suggestions": suggestions,
+            },
+            context={
+                "conversation_id": self.conversation_id or "error",
+                "session_id": self.session_id or "error",
+                "iteration": 0,
+                "error_type": "validation",
+            },
+        )
+
+    def create_rejection_message(
+        self,
+        bayko_response: Dict[str, Any],
+        evaluation: Dict[str, Any],
+        iteration: int,
+    ) -> AgentMessage:
+        """Create rejection message for auto-rejected content"""
+        return AgentMessage(
+            message_id=f"msg_{uuid.uuid4().hex[:8]}",
+            timestamp=datetime.utcnow().isoformat() + "Z",
+            sender="agent_brown",
+            recipient="user_interface",
+            message_type=MessageType.VALIDATION_ERROR.value,
+            payload={
+                "error": "Content rejected",
+                "reason": evaluation["reason"],
+                "rejected_content": bayko_response,
+                "auto_rejection": True,
+            },
+            context={
+                "conversation_id": self.conversation_id,
+                "session_id": self.session_id,
+                "iteration": iteration,
+                "rejection_type": "quality",
+            },
+        )
+
+    def create_refinement_message(
+        self,
+        bayko_response: Dict[str, Any],
+        feedback: Dict[str, Any],
+        iteration: int,
+    ) -> AgentMessage:
+        """Create refinement request message"""
+        return AgentMessage(
+            message_id=f"msg_{uuid.uuid4().hex[:8]}",
+            timestamp=datetime.utcnow().isoformat() + "Z",
+            sender="agent_brown",
+            recipient="agent_bayko",
+            message_type=MessageType.REFINEMENT_REQUEST.value,
+            payload={
+                "original_content": bayko_response,
+                "feedback": feedback,
+                "specific_improvements": feedback.get(
+                    "improvement_suggestions", []
+                ),
+                "focus_areas": [
+                    area
+                    for area, score in [
+                        ("adherence", feedback.get("adherence_score", 0)),
+                        (
+                            "style_consistency",
+                            feedback.get("style_consistency", 0),
+                        ),
+                        ("narrative_flow", feedback.get("narrative_flow", 0)),
+                        (
+                            "technical_quality",
+                            feedback.get("technical_quality", 0),
+                        ),
+                    ]
+                    if score < 0.7
+                ],
+                "iteration": iteration,
+            },
+            context={
+                "conversation_id": self.conversation_id,
+                "session_id": self.session_id,
+                "iteration": iteration,
+                "previous_feedback": feedback,
+                "refinement_reason": "Quality below threshold",
+            },
+        )
+
+    def create_approval_message(
+        self,
+        bayko_response: Dict[str, Any],
+        feedback: Dict[str, Any],
+        iteration: int,
+    ) -> AgentMessage:
+        """Create final approval message"""
+        return AgentMessage(
+            message_id=f"msg_{uuid.uuid4().hex[:8]}",
+            timestamp=datetime.utcnow().isoformat() + "Z",
+            sender="agent_brown",
+            recipient="user_interface",
+            message_type=MessageType.FINAL_APPROVAL.value,
+            payload={
+                "approved_content": bayko_response,
+                "final_feedback": feedback,
+                "session_summary": {
+                    "total_iterations": iteration,
+                    "final_score": feedback.get("overall_score", 0),
+                    "processing_complete": True,
+                },
+            },
+            context={
+                "conversation_id": self.conversation_id,
+                "session_id": self.session_id,
+                "iteration": iteration,
+                "final_approval": True,
+                "completion_timestamp": datetime.utcnow().isoformat() + "Z",
+            },
+        )

services/session_id_generator.py

@@ -0,0 +1,43 @@
+"""
+Session ID Generator Service
+Provides consistent session ID generation across the application.
+"""
+
+import re
+import uuid
+from datetime import datetime
+from typing import Optional
+
+
+class SessionIdGenerator:
+    """Generates consistent session IDs across the application"""
+
+    @staticmethod
+    def create_session_id(prefix: Optional[str] = None) -> str:
+        """
+        Create a new session ID.
+        For production: Uses UUID format
+        For testing: Uses sequential format with optional prefix
+        """
+        if prefix:
+            # Use consistent format for test sessions
+            session_num = uuid.uuid4().int % 1000  # Get last 3 digits
+            return f"{prefix}_{session_num:03d}"
+
+        # Production session ID - UUID based
+        return str(uuid.uuid4())
+
+    @staticmethod
+    def is_valid_session_id(session_id: str) -> bool:
+        """Validate if a session ID follows the expected format"""
+        # UUID format (production)
+        uuid_pattern = (
+            r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
+        )
+        # Test format (test_001, etc)
+        test_pattern = r"^[a-z]+_\d{3}$"
+
+        return bool(
+            re.match(uuid_pattern, session_id, re.I)
+            or re.match(test_pattern, session_id)
+        )

services/session_manager.py

@@ -0,0 +1,114 @@
+"""
+Session Manager Service
+Handles file I/O operations for session state management.
+"""
+
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any
+from dataclasses import asdict
+
+from services.message_factory import AgentMessage
+
+logger = logging.getLogger(__name__)
+
+
+class SessionManager:
+    """Manages session state persistence and file operations"""
+
+    def __init__(self, session_id: str, conversation_id: str):
+        self.session_id = session_id
+        self.conversation_id = conversation_id
+        self.session_dir = Path(f"storyboard/{session_id}")
+        self.agents_dir = self.session_dir / "agents"
+
+    def save_session_state(
+        self,
+        message: AgentMessage,
+        request_data: Dict[str, Any],
+        memory_history: list,
+        iteration_count: int,
+    ):
+        """Save session state to disk following tech_specs.md structure"""
+        try:
+            # Create session directory structure
+            self.agents_dir.mkdir(parents=True, exist_ok=True)
+
+            # Save Brown's state
+            brown_state = {
+                "session_id": self.session_id,
+                "conversation_id": self.conversation_id,
+                "iteration_count": iteration_count,
+                "memory": memory_history,
+                "last_message": message.to_dict(),
+                "original_request": request_data,
+                "created_at": datetime.utcnow().isoformat() + "Z",
+            }
+
+            with open(self.agents_dir / "brown_state.json", "w") as f:
+                json.dump(brown_state, f, indent=2)
+
+            # Save conversation log
+            self._save_conversation_log(message)
+
+            logger.info(f"Saved session state to {self.session_dir}")
+
+        except Exception as e:
+            logger.error(f"Failed to save session state: {e}")
+
+    def _save_conversation_log(self, message: AgentMessage):
+        """Save or update conversation log"""
+        conversation_log = {
+            "conversation_id": self.conversation_id,
+            "session_id": self.session_id,
+            "messages": [message.to_dict()],
+            "created_at": datetime.utcnow().isoformat() + "Z",
+            "updated_at": datetime.utcnow().isoformat() + "Z",
+        }
+
+        log_file = self.agents_dir / "conversation_log.json"
+        if log_file.exists():
+            # Append to existing log
+            try:
+                with open(log_file, "r") as f:
+                    existing_log = json.load(f)
+                existing_log["messages"].append(message.to_dict())
+                existing_log["updated_at"] = conversation_log["updated_at"]
+                conversation_log = existing_log
+            except Exception as e:
+                logger.warning(
+                    f"Could not read existing log, creating new: {e}"
+                )
+
+        with open(log_file, "w") as f:
+            json.dump(conversation_log, f, indent=2)
+
+    def load_session_state(self) -> Dict[str, Any]:
+        """Load session state from disk"""
+        try:
+            state_file = self.agents_dir / "brown_state.json"
+            if state_file.exists():
+                with open(state_file, "r") as f:
+                    return json.load(f)
+        except Exception as e:
+            logger.error(f"Failed to load session state: {e}")
+
+        return {}
+
+    def session_exists(self) -> bool:
+        """Check if session directory exists"""
+        return self.session_dir.exists()
+
+    def get_conversation_log(self) -> Dict[str, Any]:
+        """Get conversation log"""
+        try:
+            log_file = self.agents_dir / "conversation_log.json"
+            if log_file.exists():
+                with open(log_file, "r") as f:
+                    return json.load(f)
+        except Exception as e:
+            logger.error(f"Failed to load conversation log: {e}")
+
+        return {"messages": []}

services/simple_evaluator.py

@@ -0,0 +1,134 @@
+class SimpleEvaluator:
+    """Basic evaluation logic for Brown's decision making"""
+
+    MAX_ATTEMPTS = 3  # Original + 2 revisions
+
+    def __init__(self):
+        self.attempt_count = 0
+
+    def evaluate(self, bayko_output: dict, original_prompt: str) -> dict:
+        """Evaluate Bayko's output and decide: approve, reject, or refine"""
+        self.attempt_count += 1
+
+        print(
+            f"🔍 Brown evaluating attempt {self.attempt_count}/{self.MAX_ATTEMPTS}"
+        )
+
+        # Rule 1: Auto-reject if dialogue in images
+        if self._has_dialogue_in_images(bayko_output):
+            return {
+                "decision": "reject",
+                "reason": "Images contain dialogue text - use subtitles instead",
+                "final": True,
+            }
+
+        # Rule 2: Auto-reject if story is incoherent
+        if not self._is_story_coherent(bayko_output):
+            return {
+                "decision": "reject",
+                "reason": "Story panels don't follow logical sequence",
+                "final": True,
+            }
+
+        # Rule 3: Force approve if max attempts reached
+        if self.attempt_count >= self.MAX_ATTEMPTS:
+            return {
+                "decision": "approve",
+                "reason": f"Max attempts ({self.MAX_ATTEMPTS}) reached - accepting current quality",
+                "final": True,
+            }
+
+        # Rule 4: Check if output matches prompt intent
+        if self._matches_prompt_intent(bayko_output, original_prompt):
+            return {
+                "decision": "approve",
+                "reason": "Output matches prompt and quality is acceptable",
+                "final": True,
+            }
+        else:
+            return {
+                "decision": "refine",
+                "reason": "Output needs improvement to better match prompt",
+                "final": False,
+            }
+
+    def _has_dialogue_in_images(self, output: dict) -> bool:
+        """Check if panels mention dialogue in the image"""
+        panels = output.get("panels", [])
+
+        dialogue_keywords = [
+            "speech bubble",
+            "dialogue",
+            "talking",
+            "saying",
+            "text in image",
+            "speech",
+            "conversation",
+        ]
+
+        for panel in panels:
+            description = panel.get("description", "").lower()
+            if any(keyword in description for keyword in dialogue_keywords):
+                print(f"❌ Found dialogue in image: {description}")
+                return True
+
+        return False
+
+    def _is_story_coherent(self, output: dict) -> bool:
+        """Basic check for story coherence"""
+        panels = output.get("panels", [])
+
+        if len(panels) < 2:
+            return True  # Single panel is always coherent
+
+        # Check 1: All panels should have descriptions
+        descriptions = [p.get("description", "") for p in panels]
+        if any(not desc.strip() for desc in descriptions):
+            print("❌ Some panels missing descriptions")
+            return False
+
+        # Check 2: Panels shouldn't be identical (no progression)
+        if len(set(descriptions)) == 1:
+            print("❌ All panels are identical - no story progression")
+            return False
+
+        # Check 3: Look for obvious incoherence keywords
+        incoherent_keywords = [
+            "unrelated",
+            "random",
+            "doesn't make sense",
+            "no connection",
+            "contradictory",
+        ]
+
+        full_text = " ".join(descriptions).lower()
+        if any(keyword in full_text for keyword in incoherent_keywords):
+            print("❌ Story contains incoherent elements")
+            return False
+
+        return True
+
+    def _matches_prompt_intent(self, output: dict, prompt: str) -> bool:
+        """Check if output generally matches the original prompt"""
+        panels = output.get("panels", [])
+
+        if not panels:
+            return False
+
+        # Simple keyword matching
+        prompt_words = set(prompt.lower().split())
+        panel_text = " ".join(
+            [p.get("description", "") for p in panels]
+        ).lower()
+        panel_words = set(panel_text.split())
+
+        # At least 20% of prompt words should appear in panel descriptions
+        overlap = len(prompt_words.intersection(panel_words))
+        match_ratio = overlap / len(prompt_words) if prompt_words else 0
+
+        print(f"📊 Prompt match ratio: {match_ratio:.2f}")
+        return match_ratio >= 0.2
+
+    def reset(self):
+        """Reset for new session"""
+        self.attempt_count = 0

services/style_tagger.py

@@ -0,0 +1,181 @@
+import uuid
+import logging
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, asdict
+from enum import Enum
+
+
+@dataclass
+class StyleAnalysis:
+    """Result of style analysis and tagging"""
+
+    detected_style: str
+    style_tags: List[str]
+    mood: str
+    color_palette: str
+    enhanced_prompt: str
+    confidence: float
+
+
+class StyleTagger:
+    """Handles style detection and tagging"""
+
+    def __init__(self):
+        self.style_mappings = {
+            "studio_ghibli": {
+                "keywords": [
+                    "ghibli",
+                    "whimsical",
+                    "nature",
+                    "peaceful",
+                    "magical",
+                ],
+                "tags": ["whimsical", "nature", "soft_lighting", "watercolor"],
+                "mood": "peaceful",
+                "color_palette": "warm_earth_tones",
+            },
+            "manga": {
+                "keywords": [
+                    "manga",
+                    "anime",
+                    "dramatic",
+                    "action",
+                    "intense",
+                ],
+                "tags": [
+                    "high_contrast",
+                    "dramatic",
+                    "speed_lines",
+                    "screentones",
+                ],
+                "mood": "dynamic",
+                "color_palette": "black_white_accent",
+            },
+            "western": {
+                "keywords": ["superhero", "comic", "bold", "heroic", "action"],
+                "tags": [
+                    "bold_lines",
+                    "primary_colors",
+                    "superhero",
+                    "action",
+                ],
+                "mood": "heroic",
+                "color_palette": "bright_primary",
+            },
+            "whisper_soft": {
+                "keywords": ["soft", "gentle", "quiet", "subtle", "whisper"],
+                "tags": ["pastel", "dreamy", "soft_focus", "ethereal"],
+                "mood": "contemplative",
+                "color_palette": "muted_pastels",
+            },
+        }
+
+        self.mood_keywords = {
+            "peaceful": ["calm", "serene", "gentle", "quiet", "peaceful"],
+            "dramatic": [
+                "intense",
+                "conflict",
+                "tension",
+                "dramatic",
+                "powerful",
+            ],
+            "whimsical": [
+                "magical",
+                "wonder",
+                "fantasy",
+                "dream",
+                "whimsical",
+            ],
+            "melancholy": [
+                "sad",
+                "lonely",
+                "lost",
+                "melancholy",
+                "bittersweet",
+            ],
+            "energetic": [
+                "action",
+                "fast",
+                "dynamic",
+                "energetic",
+                "exciting",
+            ],
+        }
+
+    def analyze_style(
+        self, prompt: str, style_preference: Optional[str] = None
+    ) -> StyleAnalysis:
+        """
+        Analyze prompt and determine appropriate style tags
+
+        Args:
+            prompt: User's story prompt
+            style_preference: Optional user-specified style preference
+
+        Returns:
+            StyleAnalysis with detected style and tags
+        """
+        prompt_lower = prompt.lower()
+
+        # If user specified a style, use it if valid
+        if (
+            style_preference
+            and style_preference.lower() in self.style_mappings
+        ):
+            style_key = style_preference.lower()
+            confidence = 0.9  # High confidence for user-specified style
+        else:
+            # Auto-detect style based on keywords
+            style_scores = {}
+            for style, config in self.style_mappings.items():
+                score = sum(
+                    1
+                    for keyword in config["keywords"]
+                    if keyword in prompt_lower
+                )
+                if score > 0:
+                    style_scores[style] = score
+
+            if style_scores:
+                style_key = max(
+                    style_scores.keys(), key=lambda x: style_scores[x]
+                )
+                confidence = min(0.8, style_scores[style_key] * 0.2)
+            else:
+                # Default to studio_ghibli for unknown styles
+                style_key = "studio_ghibli"
+                confidence = 0.5
+
+        style_config = self.style_mappings[style_key]
+
+        # Detect mood
+        detected_moods = []
+        for mood, keywords in self.mood_keywords.items():
+            if any(keyword in prompt_lower for keyword in keywords):
+                detected_moods.append(mood)
+
+        # Use style's default mood if none detected
+        final_mood = (
+            detected_moods[0] if detected_moods else style_config["mood"]
+        )
+
+        # Enhance prompt with style information
+        enhanced_prompt = self._enhance_prompt(
+            prompt, style_config, final_mood
+        )
+
+        return StyleAnalysis(
+            detected_style=style_key,
+            style_tags=style_config["tags"],
+            mood=final_mood,
+            color_palette=style_config["color_palette"],
+            enhanced_prompt=enhanced_prompt,
+            confidence=confidence,
+        )
+
+    def _enhance_prompt(
+        self, original_prompt: str, style_config: Dict, mood: str
+    ) -> str:
+        """Enhance the original prompt with style-specific details"""
+        style_descriptors = ", ".join(style_config["tags"])
+        return f"{original_prompt}. Visual style: {style_descriptors}, mood: {mood}, color palette: {style_config['color_palette']}"

services/unified_memory.py

@@ -0,0 +1,111 @@
+"""
+Unified Memory System
+Combines active conversation memory with persistent SQLite storage
+"""
+
+import sqlite3
+from datetime import datetime
+from typing import List, Dict, Any
+
+
+class AgentMemory:
+    """Unified memory system with both active conversation and persistent storage"""
+
+    def __init__(
+        self, session_id: str, agent_name: str, db_path: str = "memory.db"
+    ):
+        self.session_id = session_id
+        self.agent_name = agent_name
+        self.db_path = db_path
+
+        # Active conversation memory (in-memory for fast access)
+        self.active_messages = []
+
+        # Initialize SQLite for persistence
+        self.conn = sqlite3.connect(db_path)
+        self._create_table()
+
+    def _create_table(self):
+        """Create SQLite table for persistent storage"""
+        with self.conn:
+            self.conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS memory (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT,
+                    agent_name TEXT,
+                    role TEXT,
+                    content TEXT,
+                    timestamp TEXT
+                )
+                """
+            )
+
+    def add_message(self, role: str, content: str):
+        """Add message to both active memory and persistent storage"""
+        timestamp = datetime.utcnow().isoformat()
+
+        # Add to active memory
+        message = {"role": role, "content": content, "timestamp": timestamp}
+        self.active_messages.append(message)
+
+        # Add to persistent storage
+        with self.conn:
+            self.conn.execute(
+                """
+                INSERT INTO memory (session_id, agent_name, role, content, timestamp)
+                VALUES (?, ?, ?, ?, ?)
+                """,
+                (self.session_id, self.agent_name, role, content, timestamp),
+            )
+
+    def get_history(self) -> List[Dict[str, Any]]:
+        """Get active conversation history"""
+        return self.active_messages.copy()
+
+    def get_session_history(
+        self, session_id: str = None
+    ) -> List[Dict[str, Any]]:
+        """Get persistent session history from SQLite"""
+        if session_id is None:
+            session_id = self.session_id
+
+        with self.conn:
+            cur = self.conn.execute(
+                """
+                SELECT role, content, timestamp
+                FROM memory
+                WHERE session_id = ?
+                ORDER BY timestamp
+                """,
+                (session_id,),
+            )
+            rows = cur.fetchall()
+
+        return [
+            {"role": row[0], "content": row[1], "timestamp": row[2]}
+            for row in rows
+        ]
+
+    def clear(self):
+        """Clear active memory (keeps persistent storage)"""
+        self.active_messages.clear()
+
+    def clear_session(self, session_id: str = None):
+        """Clear persistent storage for a session"""
+        if session_id is None:
+            session_id = self.session_id
+
+        with self.conn:
+            self.conn.execute(
+                "DELETE FROM memory WHERE session_id = ?", (session_id,)
+            )
+
+    def get_memory_size(self) -> int:
+        """Get size of active memory"""
+        return len(self.active_messages)
+
+    def close(self):
+        """Close database connection"""
+        if self.conn:
+            self.conn.close()

tech_specs.md

@@ -0,0 +1,307 @@
+# Technical Specs
+
+## 🔄 Multi-Turn Agent Communication
+
+### Feedback Loop Implementation
+
+1. **Initial Request**: Brown sends structured prompt to Bayko
+2. **Content Generation**: Bayko processes via Modal + sponsor APIs
+3. **Quality Validation**: Brown evaluates output against original intent
+4. **Iterative Refinement**: Up to 3 feedback cycles with specific improvement requests
+5. **Final Assembly**: Brown compiles approved content into deliverable format
+
+### Agent Message Schema
+
+```json
+{
+  "message_id": "msg_001",
+  "timestamp": "2025-01-15T10:30:00Z",
+  "sender": "agent_brown",
+  "recipient": "agent_bayko",
+  "message_type": "generation_request",
+  "payload": {
+    "prompt": "A moody K-pop idol finds a puppy",
+    "style_tags": ["studio_ghibli", "whisper_soft_lighting"],
+    "panels": 4,
+    "language": "korean",
+    "extras": ["narration", "subtitles"]
+  },
+  "context": {
+    "conversation_id": "conv_001",
+    "iteration": 1,
+    "previous_feedback": null
+  }
+}
+```
+
+---
+
+## 📁 File Organization & Data Standards
+
+### Output Directory Structure
+
+```text
+/storyboard/
+├── session_001/
+│   ├── agents/
+│   │   ├── brown_state.json      # Agent Brown memory/state
+│   │   ├── bayko_state.json      # Agent Bayko memory/state
+│   │   └── conversation_log.json # Inter-agent messages
+│   ├── content/
+│   │   ├── panel_1.png          # Generated images
+│   │   ├── panel_1_audio.mp3    # TTS narration
+│   │   ├── panel_1_subs.vtt     # Subtitle files
+│   │   └── metadata.json        # Content metadata
+│   ├── iterations/
+│   │   ├── v1_feedback.json     # Validation feedback
+│   │   ├── v2_refinement.json   # Refinement requests
+│   │   └── final_approval.json  # Final validation
+│   └── output/
+│       ├── final_comic.png      # Assembled comic
+│       ├── manifest.json        # Complete session data
+│       └── performance_log.json # Timing/cost metrics
+```
+
+### Metadata Standards
+
+```json
+{
+  "session_id": "session_001",
+  "created_at": "2025-01-15T10:30:00Z",
+  "user_prompt": "Original user input",
+  "processing_stats": {
+    "total_iterations": 2,
+    "processing_time_ms": 45000,
+    "api_calls": {
+      "openai": 3,
+      "mistral": 2,
+      "modal": 8
+    },
+    "cost_breakdown": {
+      "compute": "$0.15",
+      "api_calls": "$0.08"
+    }
+  },
+  "quality_metrics": {
+    "brown_approval_score": 0.92,
+    "style_consistency": 0.88,
+    "prompt_adherence": 0.95
+  }
+}
+```
+
+---
+
+## ⚙️ Tool Orchestration & API Integration
+
+### Modal Compute Layer
+
+```python
+# Modal function for SDXL image generation
+@app.function(
+    image=modal.Image.debian_slim().pip_install("diffusers", "torch"),
+    gpu="A10G",
+    timeout=300
+)
+def generate_comic_panel(prompt: str, style: str) -> bytes:
+    # SDXL pipeline with HuggingFace integration
+    return generated_image_bytes
+```
+
+### Sponsor API Integration
+
+- **OpenAI GPT-4**: Dialogue generation and character voice consistency
+- **Mistral**: Style adaptation and tone refinement
+- **HuggingFace**: SDXL model hosting and inference
+- **Modal**: Serverless GPU compute for image/audio generation
+
+> Mistral Agents: Investigated experimental client.beta.agents framework for dynamic task routing, but deferred due to limited stability at time of build.
+
+### LlamaIndex Agent Memory
+
+```python
+from llama_index.core.agent import ReActAgent
+from llama_index.core.memory import ChatMemoryBuffer
+
+# Agent Brown with persistent memory
+brown_agent = ReActAgent.from_tools(
+    tools=[validation_tool, feedback_tool, assembly_tool],
+    memory=ChatMemoryBuffer.from_defaults(token_limit=4000),
+    verbose=True
+)
+```
+
+---
+
+## 🌐 Gradio-FastAPI Integration
+
+### Frontend Architecture
+
+```python
+import gradio as gr
+from fastapi import FastAPI
+import asyncio
+
+app = FastAPI()
+
+# Gradio interface with real-time updates
+def create_comic_interface():
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        # Input components
+        prompt_input = gr.Textbox(label="Story Prompt")
+        style_dropdown = gr.Dropdown(["Studio Ghibli", "Manga", "Western"])
+
+        # Real-time status display
+        status_display = gr.Markdown("Ready to generate...")
+        progress_bar = gr.Progress()
+
+        # Agent thinking display
+        agent_logs = gr.JSON(label="Agent Decision Log", visible=True)
+
+        # Output gallery
+        comic_output = gr.Gallery(label="Generated Comic Panels")
+
+        # WebSocket connection for real-time updates
+        demo.load(setup_websocket_connection)
+
+    return demo
+```
+
+### Real-Time Agent Status Updates
+
+- **Agent Thinking Display**: Live JSON feed of agent decision-making
+- **Progress Tracking**: Visual progress bar with stage indicators
+- **Error Handling**: Graceful failure recovery with user feedback
+- **Performance Metrics**: Real-time cost and timing information
+
+---
+
+## 🚀 Deployment Configuration
+
+### HuggingFace Spaces Frontend
+
+```yaml
+# spaces_config.yml
+title: Agentic Comic Generator
+emoji: 🎨
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: '4.0.0'
+app_file: app.py
+pinned: false
+license: mit
+```
+
+### Modal Backend Services
+
+```python
+# modal_app.py
+import modal
+
+app = modal.App("agentic-comic-generator")
+
+# Shared volume for agent state persistence
+volume = modal.Volume.from_name("comic-generator-storage")
+
+@app.function(
+    image=modal.Image.debian_slim().pip_install_from_requirements("requirements.txt"),
+    volumes={"/storage": volume},
+    keep_warm=1
+)
+def agent_orchestrator():
+    # Main agent coordination logic
+    pass
+```
+
+### Environment Configuration
+
+```python
+# config.py
+import os
+from pydantic import BaseSettings
+
+class Settings(BaseSettings):
+    # Sponsor API Keys
+    openai_api_key: str = os.getenv("OPENAI_API_KEY")
+    mistral_api_key: str = os.getenv("MISTRAL_API_KEY")
+    hf_token: str = os.getenv("HF_TOKEN")
+
+    # Modal configuration
+    modal_token_id: str = os.getenv("MODAL_TOKEN_ID")
+    modal_token_secret: str = os.getenv("MODAL_TOKEN_SECRET")
+
+    # Application settings
+    max_iterations: int = 3
+    timeout_seconds: int = 300
+    debug_mode: bool = False
+```
+
+---
+
+## 🔧 Extensibility Framework
+
+### Plugin Architecture
+
+```python
+# plugins/base.py
+from abc import ABC, abstractmethod
+
+class ContentPlugin(ABC):
+    @abstractmethod
+    async def generate(self, prompt: str, context: dict) -> dict:
+        pass
+
+    @abstractmethod
+    def validate(self, content: dict) -> bool:
+        pass
+
+# plugins/tts_plugin.py
+class TTSPlugin(ContentPlugin):
+    async def generate(self, text: str, voice: str) -> bytes:
+        # TTS implementation using sponsor APIs
+        pass
+```
+
+### Agent Extension Points
+
+- **Custom Tools**: Easy integration of new AI services
+- **Memory Backends**: Swappable persistence layers (Redis, PostgreSQL)
+- **Validation Rules**: Configurable content quality checks
+- **Output Formats**: Support for video, interactive comics, AR content
+
+### API Abstraction Layer
+
+```python
+# services/ai_service.py
+class AIServiceRouter:
+    def __init__(self):
+        self.providers = {
+            "dialogue": OpenAIService(),
+            "style": MistralService(),
+            "image": HuggingFaceService(),
+            "compute": ModalService()
+        }
+
+    async def route_request(self, service_type: str, payload: dict):
+        return await self.providers[service_type].process(payload)
+```
+
+---
+
+## 📊 Performance & Monitoring
+
+### Metrics Collection
+
+- **Agent Performance**: Decision time, iteration counts, success rates
+- **API Usage**: Cost tracking, rate limiting, error rates
+- **User Experience**: Generation time, satisfaction scores
+- **System Health**: Resource utilization, error logs
+
+#### Cost Optimization
+
+- **Smart Caching**: Reuse similar generations across sessions
+- **Batch Processing**: Group API calls for efficiency
+- **Fallback Strategies**: Graceful degradation when services are unavailable
+
+---

tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for Bayko agents"""

tests/conftest.py

@@ -0,0 +1,9 @@
+"""Configure pytest to add project root to path"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add project root to Python path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))

tests/test_bayko_llm_integration.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""
+Comprehensive test for Agent Bayko LLM integration
+Tests both LLM and fallback modes with proper session management
+"""
+
+import os
+import asyncio
+import json
+from pathlib import Path
+from agents.bayko import create_agent_bayko
+
+# Load environment variables
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv()
+except ImportError:
+    pass
+
+try:
+    from openai import OpenAI
+except ImportError:
+    OpenAI = None
+
+
+async def test_bayko_llm_integration():
+    """Comprehensive test of Bayko LLM integration"""
+
+    print("🧪 Testing Agent Bayko LLM Integration")
+    print("=" * 60)
+
+    # Test 1: Bayko without LLM (fallback mode)
+    print("\n1️⃣ Testing Bayko without LLM (fallback mode)")
+    print("-" * 40)
+    bayko_fallback = create_agent_bayko(llm=None)
+
+    # Test prompt generation fallback
+    description = "A K-pop idol walking alone in the rain, feeling melancholy"
+    style_tags = ["whimsical", "soft_lighting", "watercolor", "studio_ghibli"]
+    mood = "melancholy"
+
+    print(f"📝 Original description: {description}")
+    print(f"🎨 Style tags: {style_tags}")
+    print(f"😔 Mood: {mood}")
+
+    result_fallback = bayko_fallback.generate_prompt_from_description(
+        description, style_tags, mood
+    )
+    print(f"🔄 Fallback result: {result_fallback}")
+
+    # Test feedback revision fallback
+    feedback = {
+        "improvement_suggestions": [
+            "Improve visual style consistency",
+            "Enhance emotional depth",
+        ],
+        "overall_score": 0.6,
+        "reason": "Needs better style consistency and emotional impact",
+    }
+    focus_areas = ["style_consistency", "narrative_flow"]
+
+    revised_fallback = bayko_fallback.revise_panel_description(
+        description, feedback, focus_areas
+    )
+    print(f"🔄 Fallback revision: {revised_fallback}")
+
+    # Test 2: Bayko with LLM (if available)
+    if OpenAI and os.getenv("OPENAI_API_KEY"):
+        print("\n2️⃣ Testing Bayko with LLM")
+        print("-" * 40)
+        try:
+            llm = OpenAI()
+            bayko_llm = create_agent_bayko(llm=llm)
+
+            print(f"📝 Original description: {description}")
+            print(f"🎨 Style tags: {style_tags}")
+            print(f"😔 Mood: {mood}")
+
+            # Test LLM prompt generation
+            print("\n🤖 Testing LLM prompt generation...")
+            result_llm = bayko_llm.generate_prompt_from_description(
+                description, style_tags, mood
+            )
+            print(f"✨ LLM enhanced prompt: {result_llm}")
+
+            # Test LLM feedback revision
+            print("\n🤖 Testing LLM feedback revision...")
+            print(f"📋 Feedback: {feedback}")
+            print(f"🎯 Focus areas: {focus_areas}")
+
+            revised_llm = bayko_llm.revise_panel_description(
+                description, feedback, focus_areas
+            )
+            print(f"✨ LLM revised description: {revised_llm}")
+
+            # Test session management and memory
+            print("\n🧠 Testing session management...")
+            session_info = bayko_llm.get_session_info()
+            print(f"📊 Session info: {session_info}")
+
+            # Check if LLM data was saved
+            if (
+                hasattr(bayko_llm, "current_session")
+                and bayko_llm.current_session
+            ):
+                session_dir = Path(
+                    f"storyboard/{bayko_llm.current_session}/llm_data"
+                )
+                if session_dir.exists():
+                    llm_files = list(session_dir.glob("*.json"))
+                    print(f"💾 LLM data files saved: {len(llm_files)}")
+                    for file in llm_files:
+                        print(f"   📄 {file.name}")
+                        # Show content of first file
+                        if file.name.startswith("generation_"):
+                            with open(file, "r") as f:
+                                data = json.load(f)
+                                print(
+                                    f"   📋 Content: {data.get('generated_prompt', 'N/A')[:100]}..."
+                                )
+                else:
+                    print("⚠️  No LLM data directory found")
+
+        except Exception as e:
+            print(f"❌ LLM test failed: {e}")
+            print(f"   Error type: {type(e).__name__}")
+            import traceback
+
+            traceback.print_exc()
+    else:
+        print("\n2️⃣ Skipping LLM test")
+        print("-" * 40)
+        if not OpenAI:
+            print("⚠️  OpenAI package not available")
+        elif not os.getenv("OPENAI_API_KEY"):
+            print("⚠️  OPENAI_API_KEY not found in environment")
+        else:
+            print("⚠️  Unknown issue with OpenAI setup")
+
+    # Test 3: Compare outputs
+    print("\n3️⃣ Comparison Summary")
+    print("-" * 40)
+    print(f"📏 Fallback prompt length: {len(result_fallback)} chars")
+    print(f"📏 Fallback revision length: {len(revised_fallback)} chars")
+
+    if "result_llm" in locals():
+        print(f"📏 LLM prompt length: {len(result_llm)} chars")
+        print(f"📏 LLM revision length: {len(revised_llm)} chars")
+        print(
+            f"🔍 LLM enhancement factor: {len(result_llm) / len(result_fallback):.2f}x"
+        )
+
+    print("\n✅ Test completed successfully!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    asyncio.run(test_bayko_llm_integration())

tests/test_bayko_workflow_init.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+Test suite for BaykoWorkflow initialization and session handling
+"""
+
+import os
+import pytest
+import asyncio
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+from services.session_id_generator import SessionIdGenerator
+
+# Add pytest-asyncio marker
+pytestmark = pytest.mark.asyncio
+
+from agents.bayko_workflow import create_agent_bayko, BaykoWorkflow
+
+# Load environment variables
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+
+def create_test_workflow(api_key: Optional[str] = None) -> BaykoWorkflow:
+    """Helper to create workflow with specified API key"""
+    return create_agent_bayko(openai_api_key=api_key)
+
+
+async def test_workflow_initialization():
+    """Test core workflow initialization"""
+    print("\n🧪 Testing BaykoWorkflow Initialization")
+    print("=" * 60)
+
+    # Test 1: With valid API key
+    if os.getenv("OPENAI_API_KEY"):
+        print("\n1️⃣ Testing initialization with API key")
+        workflow = create_test_workflow(os.getenv("OPENAI_API_KEY"))
+
+        assert workflow.llm is not None, "LLM should be initialized"
+        assert workflow.agent is not None, "ReActAgent should be initialized"
+        assert (
+            workflow.bayko_agent is not None
+        ), "Bayko agent should be initialized"
+        assert workflow.tools is not None, "Tools should be initialized"
+        print("✅ Workflow initialized with LLM capabilities")
+
+    # Test 2: Without API key
+    print("\n2️⃣ Testing initialization without API key")
+    workflow_no_llm = create_test_workflow(None)
+
+    assert workflow_no_llm.llm is None, "LLM should not be initialized"
+    assert (
+        workflow_no_llm.agent is None
+    ), "ReActAgent should not be initialized"
+    assert (
+        workflow_no_llm.bayko_agent is not None
+    ), "Bayko agent should still be initialized"
+    assert (
+        workflow_no_llm.tools is not None
+    ), "Tools should still be initialized"
+    print("✅ Workflow initialized in fallback mode")
+
+
+async def test_session_initialization():
+    """Test session initialization and handling"""
+    print("\n🧪 Testing Session Initialization")
+    print("=" * 60)
+
+    workflow = create_test_workflow(os.getenv("OPENAI_API_KEY"))    # Test 1: Basic session initialization
+    print("\n1️⃣ Testing basic session initialization")
+    session_id = SessionIdGenerator.create_session_id("test")
+    workflow.initialize_session(session_id)
+
+    assert (
+        workflow.session_manager is not None
+    ), "Session manager should be initialized"
+    assert workflow.memory is not None, "Memory should be initialized"
+    assert (
+        workflow.message_factory is not None
+    ), "Message factory should be initialized"
+    print("✅ Session services initialized")
+
+    # Test 2: Session with custom conversation ID    print("\n2️⃣ Testing session with custom conversation ID")
+    session_id = SessionIdGenerator.create_session_id("test")
+    conv_id = "custom_conv_001"
+    workflow.initialize_session(session_id, conv_id)
+
+    assert (
+        workflow.session_manager is not None
+    ), "Session manager should be initialized"
+    assert workflow.memory is not None, "Memory should be initialized"
+    print("✅ Session initialized with custom conversation ID")
+
+
+async def test_generation_request():
+    """Test generation request handling"""    print("\n🧪 Testing Generation Request Processing")
+    print("=" * 60)
+    workflow = create_test_workflow(os.getenv("OPENAI_API_KEY"))
+    session_id = SessionIdGenerator.create_session_id("test")
+    workflow.initialize_session(session_id)
+
+    # Create test request
+    test_request = {
+        "prompt": "A curious robot exploring a garden for the first time",
+        "original_prompt": "Robot discovers nature",
+        "style_tags": ["whimsical", "soft_lighting", "watercolor"],
+        "panels": 2,
+        "session_id": session_id,
+    }
+
+    # Test 1: Process with LLM if available
+    print("\n1️⃣ Testing generation request processing")
+    result = workflow.process_generation_request(test_request)
+    assert result is not None, "Should get a result"
+    print("✅ Successfully processed generation request")
+
+    # Test 2: Verify fallback works
+    print("\n2️⃣ Testing fallback generation")
+    workflow_no_llm = create_test_workflow(None)
+    workflow_no_llm.initialize_session(session_id)
+
+    fallback_result = workflow_no_llm.process_generation_request(test_request)
+    assert fallback_result is not None, "Should get a fallback result"
+    assert (
+        "fallback" in fallback_result.lower()
+    ), "Should indicate fallback mode"
+    print("✅ Fallback generation works")
+
+
+async def main():
+    """Run all tests"""
+    print("🚀 Starting BaykoWorkflow Tests")
+    print("=" * 80)
+
+    try:
+        await test_workflow_initialization()
+        await test_session_initialization()
+        await test_generation_request()
+
+        print("\n✨ All tests completed successfully!")
+    except AssertionError as e:
+        print(f"\n❌ Test failed: {str(e)}")
+    except Exception as e:
+        print(f"\n❌ Unexpected error: {str(e)}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tests/test_brown_multimodal.py

@@ -0,0 +1,60 @@
+"""
+Demo: Agent Brown with LlamaIndex ReActAgent
+Shows how the original AgentBrown is used with LlamaIndex tools for hackathon
+"""
+
+import os
+from dotenv import load_dotenv, find_dotenv
+from agents.brown_workflow import create_brown_workflow
+
+load_dotenv(find_dotenv())
+
+print("DEBUG: loading .env...")
+load_dotenv()
+print("DEBUG: key =", os.getenv("OPENAI_API_KEY"))
+
+
+def main():
+    """Demo the multimodal Brown agent using your original AgentBrown class"""
+
+    print("🤖 Agent Brown + LlamaIndex ReActAgent Demo")
+    print("=" * 60)
+    print("✅ Using your original AgentBrown class with LlamaIndex tools")
+    print("🏆 Hackathon demo showcasing ReAct reasoning")
+    print("=" * 60)
+
+    # Check API key
+    if not os.getenv("OPENAI_API_KEY"):
+        print("❌ Please set OPENAI_API_KEY environment variable")
+        print("Example: export OPENAI_API_KEY='your-key-here'")
+        return
+
+    # Create workflow (uses your original AgentBrown internally)
+    print("🔧 Creating Brown workflow with LlamaIndex ReActAgent...")
+    workflow = create_brown_workflow(max_iterations=3)
+    print("✅ Ready!")
+
+    # Demo prompt
+    prompt = """A moody K-pop idol finds a puppy on the street. It changes everything. 
+    Use Studio Ghibli style with soft colors and 4 panels."""
+
+    print(f"\n📝 Demo Prompt:")
+    print(f"'{prompt}'")
+    print("\n🔄 Processing with Agent Brown ReActAgent...")
+    print("(Watch for Thought → Action → Observation pattern)")
+    print("=" * 60)
+
+    # Process with visible reasoning
+    result = workflow.process_comic_request(prompt)
+
+    print("\n" + "=" * 60)
+    print("🎉 Final Result:")
+    print(result)
+    print("=" * 60)
+    print(
+        "✅ Demo complete! Your original AgentBrown methods were used as tools."
+    )
+
+
+if __name__ == "__main__":
+    main()

tests/test_complete_integration.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""
+Complete integration test for Agent Bayko LlamaIndex workflow
+Tests ReActAgent, FunctionTools, Memory, and LLM integration
+"""
+
+import os
+import asyncio
+import json
+from pathlib import Path
+
+# Load environment variables
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv()
+except ImportError:
+    pass
+
+from agents.bayko_workflow import create_agent_bayko
+
+
+async def test_complete_integration():
+    """Test complete Bayko workflow integration"""
+
+    print("🏆 Testing Complete Agent Bayko LlamaIndex Integration")
+    print("=" * 70)
+    print("🎯 Demonstrating: ReActAgent + FunctionTools + Memory + LLM")
+    print("=" * 70)
+
+    # Test 1: Create workflow with LLM
+    if os.getenv("OPENAI_API_KEY"):
+        print("\n1️⃣ Creating Bayko Workflow with LlamaIndex ReActAgent")
+        print("-" * 50)
+
+        try:
+            # Create workflow
+            bayko_workflow = create_agent_bayko(
+                openai_api_key=os.getenv("OPENAI_API_KEY")
+            )
+
+            # Initialize session
+            session_id = "hackathon_demo_001"
+            bayko_workflow.initialize_session(session_id)
+
+            print(
+                f"✅ Workflow created with LLM: {bayko_workflow.llm is not None}"
+            )
+            print(f"✅ ReActAgent created: {bayko_workflow.agent is not None}")
+            print(f"✅ Tools available: {len(bayko_workflow.tools)}")
+            print(f"✅ Session initialized: {session_id}")
+
+            # List available tools
+            print("\n🛠️ Available LlamaIndex FunctionTools:")
+            for i, tool in enumerate(bayko_workflow.tools, 1):
+                print(
+                    f"   {i}. {tool.metadata.name}: {tool.metadata.description[:60]}..."
+                )
+
+            # Test 2: Test individual tools
+            print("\n2️⃣ Testing Individual LlamaIndex FunctionTools")
+            print("-" * 50)
+
+            # Test enhanced prompt generation
+            print("🤖 Testing generate_enhanced_prompt tool...")
+            prompt_result = (
+                bayko_workflow.bayko_tools.generate_enhanced_prompt_tool(
+                    description="A melancholic K-pop idol walking in rain",
+                    style_tags='["whimsical", "soft_lighting", "watercolor"]',
+                    mood="melancholy",
+                )
+            )
+            prompt_data = json.loads(prompt_result)
+            print(
+                f"✨ Enhanced prompt: {prompt_data['enhanced_prompt'][:100]}..."
+            )
+            print(f"🎨 LLM used: {prompt_data['llm_used']}")
+
+            # Test session info
+            print("\n📊 Testing get_session_info tool...")
+            session_result = bayko_workflow.bayko_tools.get_session_info_tool()
+            session_data = json.loads(session_result)
+            print(f"📋 Session ID: {session_data['session_id']}")
+            print(f"🧠 Memory size: {session_data['memory_size']}")
+            print(f"🤖 LLM available: {session_data['llm_available']}")
+
+            # Test 3: Test ReActAgent workflow
+            print("\n3️⃣ Testing LlamaIndex ReActAgent Workflow")
+            print("-" * 50)
+
+            # Create test request
+            test_request = {
+                "prompt": prompt_data["enhanced_prompt"],
+                "original_prompt": "A melancholic K-pop idol walking in rain",
+                "style_tags": ["whimsical", "soft_lighting", "watercolor"],
+                "panels": 2,
+                "language": "english",
+                "extras": ["narration"],
+                "session_id": session_id,
+            }
+
+            print("🎯 Processing request through ReActAgent...")
+            workflow_result = bayko_workflow.process_generation_request(
+                test_request
+            )
+            print(
+                f"🎉 Workflow completed: {len(workflow_result)} chars response"
+            )
+
+            # Test 4: Verify session data persistence
+            print("\n4️⃣ Testing Session Data Persistence")
+            print("-" * 50)
+
+            # Check if session directory was created
+            session_dir = Path(f"storyboard/{session_id}")
+            if session_dir.exists():
+                print(f"✅ Session directory created: {session_dir}")
+
+                # Check for LLM data
+                llm_dir = session_dir / "llm_data"
+                if llm_dir.exists():
+                    llm_files = list(llm_dir.glob("*.json"))
+                    print(f"💾 LLM data files: {len(llm_files)}")
+                    for file in llm_files:
+                        print(f"   📄 {file.name}")
+                else:
+                    print("⚠️ No LLM data directory found")
+
+                # Check for agent data
+                agents_dir = session_dir / "agents"
+                if agents_dir.exists():
+                    agent_files = list(agents_dir.glob("*.json"))
+                    print(f"🤖 Agent data files: {len(agent_files)}")
+                    for file in agent_files:
+                        print(f"   📄 {file.name}")
+                else:
+                    print("⚠️ No agents data directory found")
+            else:
+                print("⚠️ Session directory not found")
+
+            # Test 5: Memory integration
+            print("\n5️⃣ Testing LlamaIndex Memory Integration")
+            print("-" * 50)
+
+            if bayko_workflow.bayko_agent.memory:
+                memory_history = (
+                    bayko_workflow.bayko_agent.memory.get_history()
+                )
+                print(f"🧠 Memory entries: {len(memory_history)}")
+
+                # Show recent memory entries
+                for i, entry in enumerate(memory_history[-3:], 1):
+                    print(
+                        f"   {i}. {entry['role']}: {entry['content'][:50]}..."
+                    )
+            else:
+                print("⚠️ No memory system found")
+
+            print("\n🏆 HACKATHON DEMO SUMMARY")
+            print("=" * 50)
+            print("✅ LlamaIndex ReActAgent: WORKING")
+            print("✅ LlamaIndex FunctionTools: WORKING")
+            print("✅ LlamaIndex Memory: WORKING")
+            print("✅ OpenAI LLM Integration: WORKING")
+            print("✅ Session Management: WORKING")
+            print("✅ Multi-Agent Workflow: WORKING")
+            print("\n🎯 Ready for LlamaIndex Prize Submission!")
+
+        except Exception as e:
+            print(f"❌ Integration test failed: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    else:
+        print("❌ OPENAI_API_KEY not found - cannot test LLM integration")
+        print("🔄 Testing fallback mode...")
+
+        # Test fallback mode
+        bayko_workflow = create_agent_bayko(openai_api_key=None)
+        bayko_workflow.initialize_session("fallback_session")
+
+        print(f"✅ Fallback workflow created")
+        print(f"⚠️ LLM available: {bayko_workflow.llm is not None}")
+        print(f"⚠️ ReActAgent available: {bayko_workflow.agent is not None}")
+
+        # Test fallback generation
+        test_request = {
+            "prompt": "A simple test prompt",
+            "panels": 2,
+            "session_id": "fallback_session",
+        }
+
+        result = bayko_workflow.process_generation_request(test_request)
+        print(f"🔄 Fallback result: {result[:100]}...")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_complete_integration())

tests/test_end_to_end.py

@@ -0,0 +1,218 @@
+"""
+End-to-end test suite for the multi-agent comic generation system.
+Tests complete workflow including:
+1. LLM & Tool Integration
+2. Error Handling
+3. Content Generation
+4. Memory & Session Management
+5. Response Validation
+"""
+
+import os
+import json
+import pytest
+import asyncio
+import shutil  # <-- Add this for cleanup
+from pathlib import Path
+from typing import Dict, Any, List
+
+from services.session_id_generator import SessionIdGenerator
+from agents.brown_workflow import BrownWorkflow, create_brown_workflow
+from agents.bayko_workflow import BaykoWorkflow, create_agent_bayko
+
+
+async def validate_session_artifacts(session_id: str) -> Dict[str, Any]:
+    """Validate session artifacts and data persistence."""
+    session_dir = Path(f"storyboard/{session_id}")
+    artifacts = {
+        "exists": session_dir.exists(),
+        "llm_data": [],
+        "agent_data": [],
+        "output": [],
+    }
+
+    if artifacts["exists"]:
+        # Check LLM data
+        llm_dir = session_dir / "llm_data"
+        if llm_dir.exists():
+            artifacts["llm_data"] = list(llm_dir.glob("*.json"))
+
+        # Check agent data
+        agents_dir = session_dir / "agents"
+        if agents_dir.exists():
+            artifacts["agent_data"] = list(agents_dir.glob("*.json"))
+
+        # Check outputs
+        output_dir = session_dir / "output"
+        if output_dir.exists():
+            artifacts["output"] = list(output_dir.glob("*.*"))
+
+    return artifacts
+
+
+def test_comic_generation_flow():
+    """Test complete comic generation flow with multiple test cases"""
+    session_id = SessionIdGenerator.create_session_id("e2e_test")
+    brown_workflow = create_brown_workflow(
+        max_iterations=3, openai_api_key=os.getenv("OPENAI_API_KEY")
+    )
+
+    # Test cases to cover different scenarios
+    test_cases = [
+        {
+            "prompt": "A moody K-pop idol finds a puppy on the street. It changes everything.",
+            "style": "Studio Ghibli",
+            "panels": 4,
+        },
+        {
+            "prompt": "A robot learns to paint in an art studio. Show emotional growth.",
+            "style": "watercolor",
+            "panels": 3,
+        },
+        # Test error case
+        {
+            "prompt": "",  # Empty prompt should trigger error
+            "style": "invalid_style",
+            "panels": -1,
+            "expected_error": True,
+        },
+    ]
+
+    successes = 0
+    failures = 0
+
+    for case in test_cases:
+        print(f"\n🧪 Testing prompt: {case['prompt']}")
+        print("=" * 80)
+
+        try:
+            # Handle error test cases
+            if case.get("expected_error", False):
+                enhanced_prompt = (
+                    f"{case['prompt']} Style preference: {case['style']}"
+                )
+                result = asyncio.run(
+                    brown_workflow.process_comic_request_async(enhanced_prompt)
+                )
+                assert (
+                    result["status"] == "error"
+                ), "Expected error status for invalid input"
+                print("✅ Error handling working as expected")
+                successes += 1
+                continue
+
+            # Regular test case
+            enhanced_prompt = (
+                f"{case['prompt']} Style preference: {case['style']}"
+            )
+            result = asyncio.run(
+                brown_workflow.process_comic_request_async(enhanced_prompt)
+            )
+
+            # Print error details if status is error
+            if result.get("status") == "error":
+                print(f"❌ Error result: {json.dumps(result, indent=2)}")
+
+            # Validate result structure
+            assert result is not None, "Workflow returned None"
+            assert "status" in result, "Missing status in result"
+            assert (
+                result["status"] == "success"
+            ), f"Failed with status: {result['status']}"
+            assert "bayko_response" in result, "Missing Bayko response"
+
+            # Validate Bayko response
+            bayko_data = result["bayko_response"]
+            assert "panels" in bayko_data, "Missing panels in Bayko response"
+            panels = bayko_data["panels"]
+
+            # Validate panel count and content
+            assert len(panels) > 0, "No panels generated"
+            assert (
+                len(panels) == case["panels"]
+            ), f"Expected {case['panels']} panels, got {len(panels)}"
+
+            for panel in panels:
+                assert "description" in panel, "Panel missing description"
+
+            # Verify session artifacts (just check session dir exists)
+            artifacts = asyncio.run(validate_session_artifacts(session_id))
+            assert artifacts["exists"], "Session directory not created"
+
+            print(f"✅ Test case passed: {case['prompt'][:30]}...")
+            successes += 1
+
+        except AssertionError as e:
+            print(f"❌ Test failed: {str(e)}")
+            failures += 1
+        except Exception as e:
+            if not case.get("expected_error", False):
+                print(f"❌ Unexpected error: {str(e)}")
+                failures += 1
+    print("\n" + "=" * 80)
+    print("🎯 Test Summary")
+    print(f"✅ Successful tests: {successes}")
+    print(f"❌ Failed tests: {failures}")
+    print(f"📊 Success rate: {(successes/(successes+failures))*100:.1f}%")
+    try:
+        # Final assertions
+        assert successes > 0, "No test cases passed"
+        assert failures == 0, "Some test cases failed"
+    except AssertionError as e:
+        print(f"❌ Test assertions failed: {str(e)}")
+        raise
+    finally:
+        # Always cleanup and reset, even if tests fail
+        try:
+            test_dir = Path(f"storyboard/{session_id}")
+            if test_dir.exists():
+                shutil.rmtree(test_dir)
+                print(f"✨ Cleaned up test directory: {test_dir}")
+        except Exception as e:
+            print(f"⚠️ Could not clean up test directory: {str(e)}")
+
+        # Reset session state
+        try:
+            brown_workflow.reset()
+            print("✨ Reset workflow state")
+        except Exception as e:
+            print(f"⚠️ Could not reset workflow state: {str(e)}")
+
+
+def main():
+    """Run all end-to-end tests"""
+    print("\n🤖 Running Comic Generator End-to-End Tests")
+    print("=" * 80)
+
+    if not os.getenv("OPENAI_API_KEY"):
+        print("❌ Please set OPENAI_API_KEY environment variable")
+        return 1
+
+    try:
+        # Run comic generation flow test
+        comic_flow_success = test_comic_generation_flow()
+        print(
+            "✅ Comic generation flow tests passed"
+            if comic_flow_success
+            else "❌ Comic generation flow tests failed"
+        )
+
+        # Final summary
+        if comic_flow_success:
+            print("\n🎉 All tests completed successfully!")
+            return 0
+        else:
+            print("\n⚠️ Some tests failed - see details above")
+            return 1
+
+    except Exception as e:
+        print(f"\n💥 Unexpected error during testing: {str(e)}")
+        import traceback
+
+        traceback.print_exc()
+        return 2
+
+
+if __name__ == "__main__":
+    exit_code = main()
+    exit(exit_code)

tests/test_integration.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+Test script for the integrated memory and evaluation system
+"""
+
+import asyncio
+from agents.brown import AgentBrown, StoryboardRequest
+from agents.bayko import AgentBayko
+
+
+async def test_integration():
+    """Test the integrated memory and evaluation system"""
+
+    print("🚀 Testing Bayko & Brown Integration")
+    print("=" * 50)
+
+    # Create agents
+    brown = AgentBrown(max_iterations=3)
+    bayko = AgentBayko()
+
+    # Create test request
+    request = StoryboardRequest(
+        prompt="A cat discovers a magical portal in the garden",
+        style_preference="studio_ghibli",
+        panels=3,
+        language="english",
+        extras=["narration", "subtitles"],
+    )
+
+    print(f"📝 User prompt: {request.prompt}")
+    print(f"🎨 Style: {request.style_preference}")
+    print(f"📊 Panels: {request.panels}")
+    print()
+
+    # Step 1: Brown processes the request
+    print("🤖 Brown processing request...")
+    brown_message = brown.process_request(request)
+
+    if brown_message.message_type == "validation_error":
+        print(f"❌ Validation failed: {brown_message.payload}")
+        return
+
+    print(f"✅ Brown created request for Bayko")
+    print(f"🧠 Brown memory size: {brown.get_session_info()['memory_size']}")
+    print()
+
+    # Step 2: Bayko generates content
+    print("🎨 Bayko generating content...")
+    bayko_result = await bayko.process_generation_request(
+        brown_message.to_dict()
+    )
+
+    print(f"✅ Bayko generated {len(bayko_result.panels)} panels")
+    print(f"⏱️  Total time: {bayko_result.total_time:.2f}s")
+    print()
+
+    # Step 3: Brown evaluates the result
+    print("🔍 Brown evaluating Bayko's output...")
+    review_result = brown.review_output(bayko_result.to_dict(), request)
+
+    if review_result:
+        print(f"📋 Review result: {review_result.message_type}")
+        if review_result.message_type == "final_approval":
+            print("🎉 Content approved!")
+        elif review_result.message_type == "refinement_request":
+            print("🔄 Refinement requested")
+        else:
+            print("❌ Content rejected")
+
+    print()
+    print("📊 Final Session Info:")
+    session_info = brown.get_session_info()
+    for key, value in session_info.items():
+        print(f"  {key}: {value}")
+
+    print()
+    print("🧠 Memory Integration Test:")
+    if brown.memory:
+        history = brown.memory.get_history()
+        print(f"  Brown memory entries: {len(history)}")
+        for i, entry in enumerate(history[-3:], 1):  # Show last 3 entries
+            print(f"    {i}. {entry.role}: {entry.content[:50]}...")
+
+    if bayko.memory:
+        history = bayko.memory.get_history()
+        print(f"  Bayko memory entries: {len(history)}")
+        for i, entry in enumerate(history[-3:], 1):  # Show last 3 entries
+            print(f"    {i}. {entry.role}: {entry.content[:50]}...")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_integration())

tests/test_refactor.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""
+Quick test to verify the refactored AgentBrown works
+"""
+
+from agents.brown import AgentBrown, StoryboardRequest
+
+
+def test_refactored_brown():
+    """Test the refactored AgentBrown"""
+    print("🧪 Testing refactored AgentBrown...")
+
+    # Create agent
+    brown = AgentBrown(max_iterations=3)
+    print("✅ AgentBrown created successfully")
+
+    # Create test request
+    request = StoryboardRequest(
+        prompt="A cat finds a magical book in an old library",
+        style_preference="anime",
+        panels=3,
+        language="english",
+        extras=["narration"],
+    )
+    print("✅ StoryboardRequest created")
+
+    # Process request
+    try:
+        message = brown.process_request(request)
+        print("✅ Request processed successfully")
+        print(f"📨 Generated message ID: {message.message_id}")
+        print(f"🎯 Message type: {message.message_type}")
+        print(f"📊 Session info: {brown.get_session_info()}")
+        return True
+    except Exception as e:
+        print(f"❌ Error processing request: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    success = test_refactored_brown()
+    if success:
+        print("\n🎉 Refactoring successful! All functionality working.")
+    else:
+        print("\n💥 Refactoring needs fixes.")

tools/fries.py

@@ -0,0 +1,201 @@
+import modal
+import os
+import random
+from services.session_id_generator import SessionIdGenerator
+
+# Load environment variables only when running locally (not in Modal's cloud)
+if modal.is_local():
+    from dotenv import load_dotenv
+
+    load_dotenv()
+
+    # Set Modal credentials from .env file
+    modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+    modal_token_secret = os.environ.get("MODAL_TOKEN_SECRET")
+
+    if modal_token_id and modal_token_secret:
+        os.environ["MODAL_TOKEN_ID"] = modal_token_id
+        os.environ["MODAL_TOKEN_SECRET"] = modal_token_secret
+
+# Define the custom Modal image with Python execution requirements
+image = modal.Image.debian_slim().pip_install(
+    "mistralai",
+    "nest_asyncio",
+    "python-dotenv",
+)
+
+app = modal.App("fries-coder", image=image)
+
+
+@app.function(
+    secrets=[modal.Secret.from_name("mistral-api")],
+    image=image,
+    retries=3,
+    timeout=300,
+)
+async def generate_and_run_script(prompt: str, session_id: str) -> dict:
+    """
+    Generate a Python script using Mistral Codestral and run it
+
+    Args:
+        prompt: Description of the script to generate
+
+    Returns:
+        dict with generated code, execution output, and status
+    """
+    import tempfile
+    import subprocess
+    from mistralai import Mistral
+
+    try:
+        # Initialize Mistral client
+        client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
+
+        # Create FIM prompt structure
+        prefix = "# Write a short, funny Python script that:\n"
+        code_start = "import random\nimport time\n\n"
+        suffix = "\n\nif __name__ == '__main__':\n    main()"
+
+        # Generate code using FIM
+        response = client.fim.complete(
+            model="codestral-latest",
+            prompt=f"{prefix}{prompt}\n{code_start}",
+            suffix=suffix,
+            temperature=0.7,
+            top_p=1,
+        )
+
+        generated_code = (
+            f"{code_start}{response.choices[0].message.content}{suffix}"
+        )
+
+        # Save to temporary file
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".py", delete=False
+        ) as f:
+            f.write(generated_code)
+            temp_path = f.name
+
+        try:
+            # Run the generated script
+            result = subprocess.run(
+                ["python", temp_path],
+                capture_output=True,
+                text=True,
+                timeout=10,  # 10 second timeout
+            )
+            output = result.stdout
+            error = None
+            status = "success"
+        except subprocess.TimeoutExpired:
+            output = "Script execution timed out after 10 seconds"
+            error = "timeout"
+            status = "timeout"
+        except subprocess.CalledProcessError as e:
+            output = e.stdout
+            error = e.stderr
+            status = "runtime_error"
+        finally:
+            # Cleanup
+            os.unlink(temp_path)
+
+        return {
+            "code": generated_code,
+            "output": output,
+            "error": error,
+            "status": status,
+        }
+
+    except Exception as e:
+        return {
+            "code": None,
+            "output": None,
+            "error": str(e),
+            "status": "generation_error",
+        }
+
+
+# Example usage
+@app.local_entrypoint()
+def main(session_id=None):
+    if session_id is None:
+        session_id = SessionIdGenerator.create_session_id("test")
+    animal = random.choice(
+        [
+            "cat",
+            "dog",
+            "fish",
+            "bird",
+            "giraffe",
+            "turtle",
+            "monkey",
+            "rabbit",
+            "puppy",
+            "animal",
+        ]
+    )
+    prompt = f"""
+create a simple ASCII art of a {animal}.
+Create ASCII art using these characters: _ - = ~ ^ \\\\ / ( ) [ ] {{ }} < > | . o O @ *
+Draw the art line by line with print statements.
+Write a short, funny Python script.
+Use only basic Python features.
+Add a joke or pun about fries in the script.
+Make it light-hearted and fun.
+End with a message about fries.
+Make sure the script runs without errors.
+"""
+
+    try:
+        print(f"\n🤖 Generating an ascii {animal} for you!")
+        result = generate_and_run_script.remote(prompt, session_id)
+
+        # print("\n📝 Generated Code:")
+        # print("=" * 40)
+        # print(result["code"])
+        print("=" * 30)
+        print("\n🎮 Code Output:")
+        print("=" * 30)
+        print("\n\n")
+        print(result["output"])
+
+        # print("\n" + "=" * 80)
+
+        print("🍟    🍟     🍟")
+        print("Golden crispy Python fries")
+        print("Coming right up!")
+        print()
+        print("Haha. Just kidding.")
+
+        if result["code"]:
+            # Save the generated code locally
+            script_file = f"storyboard/{session_id}/output/fries_for_you.py"
+            os.makedirs(os.path.dirname(script_file), exist_ok=True)
+            with open(script_file, "w") as f:
+                f.write(result["code"])
+            print("\nGo here to check out your actual custom code:")
+            print(f"👉 Code saved to: {script_file}")
+            print("\n\n\n")
+
+        if result["error"]:
+            print("\n❌ Error:")
+            print("=" * 40)
+            print(result["error"])
+
+        if result["error"]:
+            print("Looks like there was an error during execution.")
+            print("Here are some extra fries to cheer you up!")
+            print("🍟    🍟     🍟")
+            print("   🍟     🍟    ")
+            print("       🍟      ")
+            print("Now with extra machine-learned crispiness.")
+
+    except modal.exception.FunctionTimeoutError:
+        print("⏰ Script execution timed out after 300 seconds and 3 tries!")
+        print("Sorry but codestral is having a hard time drawing today.")
+        print("Here's a timeout fry for you! 🍟")
+        print("Here are some extra fries to cheer you up!")
+        print("🍟    🍟     🍟")
+        print("   🍟     🍟    ")
+        print("       🍟      ")
+        print("Now with extra machine-learned crispiness.")

tools/fries_mcp.json

@@ -0,0 +1,39 @@
+{
+  "schema_version": "1.0",
+  "name": "fries_script_generator",
+  "description": "Generate and run short, funny Python scripts using Codestral via Modal",
+  "version": "1.0.0",
+  "input_schema": {
+    "type": "object",    "properties": {
+      "prompt": {
+        "type": "string",
+        "description": "A natural language description of the script to generate",
+        "minLength": 1,
+        "maxLength": 1000
+      }
+    },
+    "required": ["prompt"]
+  },
+  "output_schema": {
+    "type": "object",
+    "properties": {
+      "code": {
+        "type": "string",
+        "description": "The generated Python code"
+      },
+      "output": {
+        "type": "string",
+        "description": "The stdout output from running the generated code"
+      },
+      "error": {
+        "type": "string",
+        "description": "Error message if script failed or timed out"
+      },
+      "status": {
+        "type": "string",
+        "description": "Status of execution: success, timeout, runtime_error, generation_error"
+      }
+    },
+    "required": ["code", "output", "status"]
+  }
+}

tools/image_generator.py

@@ -0,0 +1,110 @@
+import modal
+import io
+import os
+from services.session_id_generator import SessionIdGenerator
+
+# Define the Modal image with required dependencies
+image = modal.Image.debian_slim().pip_install(
+    "diffusers",
+    "transformers",
+    "torch",
+    "safetensors",
+    "accelerate",
+    "Pillow",
+    "python-dotenv",  # Add this for .env support
+)
+
+# Load environment variables only when running locally (not in Modal's cloud)
+if modal.is_local():
+    from dotenv import load_dotenv
+
+    load_dotenv()
+
+    # Set Modal credentials from .env file
+    modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+    modal_token_secret = os.environ.get("MODAL_TOKEN_SECRET")
+
+    if modal_token_id and modal_token_secret:
+        os.environ["MODAL_TOKEN_ID"] = modal_token_id
+        os.environ["MODAL_TOKEN_SECRET"] = modal_token_secret
+
+
+app = modal.App("comic-image-generator", image=image)
+
+
+class ComicImageGenerator:
+    def __init__(self):
+        from diffusers import AutoPipelineForText2Image
+        import torch
+
+        self.pipe = AutoPipelineForText2Image.from_pretrained(
+            "stabilityai/sdxl-turbo",
+            torch_dtype=torch.float16,
+            variant="fp16",
+        )
+        self.pipe.to("cuda")
+        self.torch = torch
+
+    def generate_comic_panel(
+        self,
+        prompt: str,
+        panel_id: int,
+        session_id: str,
+        steps: int = 1,
+        seed: int = 42,
+    ) -> tuple:
+        import time
+
+        generator = self.torch.manual_seed(seed)
+        start = time.time()
+        result = self.pipe(
+            prompt=prompt,
+            generator=generator,
+            num_inference_steps=steps,
+            guidance_scale=0.0,
+            width=512,
+            height=512,
+            output_type="pil",
+        )
+        duration = time.time() - start
+        image = result.images[0]
+        buf = io.BytesIO()
+        image.save(buf, format="PNG")
+        buf.seek(0)
+        return buf.read(), duration
+
+
+@app.function(image=image, gpu="A10G")
+def generate_comic_panel(
+    prompt: str,
+    panel_id: int,
+    session_id: str,
+    steps: int = 1,
+    seed: int = 42,
+) -> tuple:
+    generator = ComicImageGenerator()
+    return generator.generate_comic_panel(
+        prompt, panel_id, session_id, steps, seed
+    )
+
+
+@app.local_entrypoint()
+def main():
+    prompt = "A K-pop idol walking through a rainy Seoul street, whimsical, soft lighting, watercolor style"
+    panel_id = 1
+    session_id = SessionIdGenerator.create_session_id("test")
+    steps = 1  # SDXL Turbo works best with 1 step
+    seed = 42
+
+    # with app.run():
+    img_bytes, duration = generate_comic_panel.remote(
+        prompt, panel_id, session_id, steps, seed
+    )
+    # Save to local directory
+    out_dir = f"storyboard/{session_id}/content"
+    os.makedirs(out_dir, exist_ok=True)
+    out_path = f"{out_dir}/panel_{panel_id}.png"
+    with open(out_path, "wb") as f:
+        f.write(img_bytes)
+    print("✅ Image generated at:", out_path)
+    print("🕒 Time taken:", duration, "seconds")

tools/scraps/ascii_art.py

@@ -0,0 +1,25 @@
+from PIL import Image
+
+# Load the image
+img = Image.open("storyboard/test_session_modal_image_gen/content/panel_1.png")
+
+# Resize the image
+width, height = 100, 60
+img = img.resize((width, height))
+
+# Convert the image to grayscale
+img = img.convert("L")
+
+# ASCII characters used to represent the image
+ascii_chars = "@%#*+=-:. "
+
+# Convert the image to ASCII art
+ascii_str = ""
+for y in range(height):
+    for x in range(width):
+        pixel = img.getpixel((x, y))
+        ascii_str += ascii_chars[pixel // 32]
+    ascii_str += "\n"
+
+# Print the ASCII art
+print(ascii_str)

tools/scraps/cooking_fries.py

@@ -0,0 +1,56 @@
+import time
+import os
+
+# Define ASCII art frames for fries cooking
+frames = [
+    r"""
+    __________
+   |          |
+   |          |
+   |          |
+   |          |
+   |__________|
+    (\_/)
+    """,
+    r"""
+    __________
+   | ~~~~~~~~ |
+   | ~~~~~~~~ |
+   | |  |  |  |
+   | |__|__|__|
+   |__________|
+    (\_/) O
+    """,
+    r"""
+    __________
+   | ~~~~~~~~ |
+   | ~~~~~~~~ |
+   | |  |  |  |
+   | |__|__|__|
+   |__________|
+    (\_/)=
+    """,
+    r"""
+    __________
+   | ~~~~~~~~ |
+   | ~~~~~~~~ |
+   | |  |  |  |
+   | |__|__|__|
+   |__________|
+    (\_/)
+    """,
+]
+
+
+# Function to clear the terminal screen
+def clear_screen():
+    os.system("cls" if os.name == "nt" else "clear")
+
+
+# Display each frame in sequence to create an animation
+while True:
+    for frame in frames:
+        clear_screen()
+        print("Cooking fries...")
+        print(frame)
+        time.sleep(0.5)

tools/scraps/cool_script.py

@@ -0,0 +1,77 @@
+import time
+import random
+
+def print_with_delay(text, delay=0.05):
+    for char in text:
+        print(char, end='', flush=True)
+        time.sleep(delay)
+    print()
+
+def main():
+    print_with_delay("Initializing time-space continuum...")
+    time.sleep(1)
+
+    print("""
+     .-""""""-.
+    /          \\
+   |            |
+   |            |
+   |,.-""""-,. |
+   \\/______\\/
+    |  __  |
+    | |..| |
+    | |__| |
+     `----`
+    """)
+
+    print_with_delay("Detected entity: Existential Toaster")
+    time.sleep(1)
+
+    print_with_delay("The toaster contemplates its existence...")
+    time.sleep(2)
+
+    print_with_delay("Toaster: 'Why must I only toast bread? Is there more to life?'")
+    time.sleep(2)
+
+    print_with_delay("Suddenly, a synthwave concert appears in the time-space continuum...")
+    time.sleep(1)
+
+    print("""
+    .-""""""-.
+   /          \\
+  |   🎵🎶🎵   |
+  |  Synthwave  |
+  |  Concert 🎸 |
+  |,.-""""-,. |
+  \\/______\\/
+   |  __  |
+   | |..| |
+   | |__| |
+    `----`
+    """)
+
+    print_with_delay("The toaster begins to vibrate...")
+    time.sleep(2)
+
+    print_with_delay("Toaster: 'I... I feel alive! The music... it speaks to me!'")
+    time.sleep(2)
+
+    print_with_delay("The toaster starts to glow and lift off the ground...")
+    time.sleep(2)
+
+    print_with_delay("Toaster: 'I am more than a toaster! I am a traveler of time and space!'")
+    time.sleep(2)
+
+    print_with_delay("The toaster vanishes into the synthwave concert, leaving behind a trail of breadcrumbs...")
+    time.sleep(2)
+
+    print_with_delay("The concert fades away, and the time-space continuum returns to normal...")
+    time.sleep(1)
+
+    print_with_delay("Log entry: The Existential Toaster has transcended its purpose.")
+    time.sleep(1)
+
+    print_with_delay("End of transmission.")
+
+if __name__ == "__main__":
+    main()

tools/scraps/dancing_animation.py

@@ -0,0 +1,38 @@
+import time
+import os
+
+# Define ASCII art frames for a simple dancing figure
+frames = [
+    r"""
+          O
+         /|\
+         / \
+    """,
+    r"""
+          O
+         /|\
+         / \
+          |  O
+         / \
+    """,
+    r"""
+          O
+         /|\
+         / \
+        O
+         / \
+    """,
+]
+
+
+# Function to clear the terminal screen
+def clear_screen():
+    os.system("cls" if os.name == "nt" else "clear")
+
+
+# Display each frame in sequence to create an animation
+while True:
+    for frame in frames:
+        clear_screen()
+        print(frame)
+        time.sleep(0.3)

tools/scraps/mandelbrot.py

@@ -0,0 +1,26 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def mandelbrot(h, w, max_iter=1000):
+    y, x = np.ogrid[-1.5 : 1.5 : h * 1j, -2 : 1 : w * 1j]
+    c = x + y * 1j
+    z = c
+    divtime = max_iter + np.zeros(z.shape, dtype=int)
+
+    for i in range(max_iter):
+        z = z**2 + c
+        diverge = z * np.conj(z) > 4
+        newly_diverged = diverge & (divtime == max_iter)
+        divtime[newly_diverged] = i
+        z[diverge] = 2
+
+    return divtime
+
+
+plt.imshow(
+    mandelbrot(400, 400), cmap="twilight_shifted", extent=(-2, 1, -1.5, 1.5)
+)
+plt.colorbar()
+plt.title("Mandelbrot Set")
+plt.show()

tools/scraps/ping_pong.py

@@ -0,0 +1,79 @@
+import time
+import os
+import keyboard
+
+# Initialize the game variables
+paddle_position = 3
+ball_position_x = 10
+ball_position_y = 5
+ball_direction_x = -1
+ball_direction_y = 1
+score = 0
+
+
+# Function to clear the terminal screen
+def clear_screen():
+    os.system("cls" if os.name == "nt" else "clear")
+
+
+# Function to draw the game
+def draw_game():
+    clear_screen()
+    # Draw the top and bottom boundaries
+    print("+----------------------+")
+    # Draw the game area
+    for y in range(10):
+        line = "|"
+        for x in range(20):
+            if x == 0 and y == paddle_position:
+                line += "|"
+            elif x == ball_position_x and y == ball_position_y:
+                line += "O"
+            else:
+                line += " "
+        line += "|"
+        print(line)
+    # Draw the bottom boundary
+    print("+----------------------+")
+    print(f"Score: {score}")
+
+
+# Main game loop
+try:
+    while True:
+        # Move the ball
+        ball_position_x += ball_direction_x
+        ball_position_y += ball_direction_y
+
+        # Ball collision with top and bottom
+        if ball_position_y <= 0 or ball_position_y >= 9:
+            ball_direction_y *= -1
+
+        # Ball collision with paddle
+        if ball_position_x <= 0 and ball_position_y == paddle_position:
+            ball_direction_x *= -1
+            score += 1
+
+        # Ball out of bounds
+        if ball_position_x < 0:
+            ball_position_x = 10
+            ball_position_y = 5
+            score -= 1
+
+        # Ball collision with right wall
+        if ball_position_x >= 19:
+            ball_direction_x *= -1
+
+        # Move the paddle with keyboard input
+        if keyboard.is_pressed("up") and paddle_position > 0:
+            paddle_position -= 1
+        if keyboard.is_pressed("down") and paddle_position < 9:
+            paddle_position += 1
+
+        # Draw the game
+        draw_game()
+
+        # Control the game speed
+        time.sleep(0.2)
+except KeyboardInterrupt:
+    print("\nGame Over")

tools/scraps/text_adventure.py

@@ -0,0 +1,72 @@
+import random
+import time
+
+
+def text_based_adventure():
+    rooms = {
+        "Entrance": {
+            "description": "You are at the entrance of an ancient temple.",
+            "exits": ["Hall", "Garden"],
+            "item": None,
+        },
+        "Hall": {
+            "description": "A grand hall with torches lighting the way.",
+            "exits": ["Entrance", "Chamber", "Kitchen"],
+            "item": "torch",
+        },
+        "Garden": {
+            "description": "A serene garden with a fountain in the center.",
+            "exits": ["Entrance", "Library"],
+            "item": "key",
+        },
+        "Chamber": {
+            "description": "A dark chamber with a mysterious aura.",
+            "exits": ["Hall"],
+            "item": "treasure",
+        },
+        "Kitchen": {
+            "description": "An old kitchen with rusted utensils.",
+            "exits": ["Hall"],
+            "item": "knife",
+        },
+        "Library": {
+            "description": "A dusty library filled with ancient books.",
+            "exits": ["Garden"],
+            "item": "book",
+        },
+    }
+
+    inventory = []
+    current_room = "Entrance"
+    path = [current_room]
+    log = []
+
+    log.append(f"Starting adventure in the {current_room}.")
+    log.append(rooms[current_room]["description"])
+
+    while True:
+        if rooms[current_room]["item"]:
+            item = rooms[current_room]["item"]
+            inventory.append(item)
+            log.append(f"You found a {item}!")
+            rooms[current_room]["item"] = None
+
+        if "treasure" in inventory:
+            log.append(
+                "Congratulations! You found the treasure and won the game!"
+            )
+            break
+
+        current_room = random.choice(rooms[current_room]["exits"])
+        if current_room not in path:
+            path.append(current_room)
+        log.append(f"Moving to the {current_room}.")
+        log.append(rooms[current_room]["description"])
+        time.sleep(1)
+
+    return "\n".join(log)
+
+
+# Run the adventure
+adventure_log = text_based_adventure()
+print(adventure_log)

tools/sdxl_generator_spec.json

@@ -0,0 +1,49 @@
+{
+  "schema_version": "1.0",
+  "name": "sdxl_turbo_generator",
+  "description": "Generate comic panel images using SDXL Turbo model via Modal compute",
+  "version": "1.0.0",
+  "input_schema": {
+    "type": "object",
+    "properties": {
+      "prompt": {
+        "type": "string",
+        "description": "The text prompt for image generation"
+      },
+      "panel_id": {
+        "type": "integer",
+        "description": "Unique identifier for the comic panel"
+      },
+      "session_id": {
+        "type": "string",
+        "description": "Session identifier for grouping related panels"
+      },
+      "steps": {
+        "type": "integer",
+        "description": "Number of inference steps (default: 1)",
+        "default": 1
+      },
+      "seed": {
+        "type": "integer",
+        "description": "Random seed for reproducibility (default: 42)",
+        "default": 42
+      }
+    },
+    "required": ["prompt", "panel_id", "session_id"]
+  },
+  "output_schema": {
+    "type": "object",
+    "properties": {
+      "image_bytes": {
+        "type": "string",
+        "description": "Base64 encoded PNG image data",
+        "contentEncoding": "base64"
+      },
+      "duration": {
+        "type": "number",
+        "description": "Time taken to generate the image in seconds"
+      }
+    },
+    "required": ["image_bytes", "duration"]
+  }
+}