Refactor: All agents on port 7860 with organized API endpoints

API_ENDPOINTS.md

@@ -0,0 +1,361 @@
+# Multi-Agent Content Generation System - API Endpoints
+
+**Base URL:** `http://localhost:7860`  
+**Port:** `7860` (all agents on single port)
+
+---
+
+## Health & Status
+
+### Health Check
+```
+GET /health
+```
+Returns system health status and current run ID.
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "run_id": "uuid",
+  "port": 7860
+}
+```
+
+### Root Endpoint
+```
+GET /
+```
+Returns API information and available endpoints.
+
+---
+
+## Pipeline Endpoints
+
+### Execute Full Pipeline
+```
+POST /api/pipeline/execute
+```
+Execute the complete 7-stage content generation pipeline.
+
+**Request Body:**
+```json
+{
+  "user_brief": "string",
+  "season_arc_document": "string",
+  "character_bible": "string",
+  "world_building_document": "string",
+  "character_voice_guide": "string",
+  "style_guide": "string",
+  "continuity_log": "string",
+  "hook_brief": "string (optional)"
+}
+```
+
+**Response:**
+```json
+{
+  "run_id": "uuid",
+  "status": "success",
+  "final_output": { ... },
+  "hf_output_url": "https://huggingface.co/...",
+  "hf_metadata_url": "https://huggingface.co/..."
+}
+```
+
+### Get Pipeline Status
+```
+GET /api/pipeline/status/{run_id}
+```
+Get the status and state of a specific pipeline run.
+
+**Response:**
+```json
+{
+  "run_id": "uuid",
+  "status": "completed|failed|running",
+  "pipeline_state": { ... }
+}
+```
+
+---
+
+## Agent Endpoints
+
+All agents run on port 7860 with dedicated endpoints.
+
+### 1. Showrunner Agent
+```
+POST /api/agents/showrunner
+```
+Generate episode directive from user brief.
+
+**Input:**
+```json
+{
+  "user_brief": "string",
+  "season_arc_document": "string",
+  "character_bible": "string"
+}
+```
+
+**Output:**
+```json
+{
+  "episode_directive": "string",
+  "story_premise": "string",
+  "tone_brief": "string",
+  "character_focus_notes": "string"
+}
+```
+
+---
+
+### 2. Story Editor Agent
+```
+POST /api/agents/story-editor
+```
+Generate episode outline from directive.
+
+**Input:**
+```json
+{
+  "episode_directive": "string",
+  "series_continuity_log": "string",
+  "character_list": ["Alex", "Jordan", "Casey", "Morgan"]
+}
+```
+
+**Output:**
+```json
+{
+  "episode_outline": "string",
+  "act_structure": "string",
+  "story_notes_for_writers": "string"
+}
+```
+
+---
+
+### 3. Cultural Consultant Agent
+```
+POST /api/agents/cultural-consultant
+```
+Review outline for cultural accuracy.
+
+**Input:**
+```json
+{
+  "episode_outline": "string",
+  "world_building_document": "string",
+  "character_list": ["Alex", "Jordan", "Casey", "Morgan"]
+}
+```
+
+**Output:**
+```json
+{
+  "cultural_accuracy_notes": "string",
+  "flagged_inaccuracies": ["issue1", "issue2"],
+  "approved_touchpoints": ["touchpoint1"],
+  "reference_suggestions": ["suggestion1"]
+}
+```
+
+---
+
+### 4. Lead Writer Agent
+```
+POST /api/agents/lead-writer
+```
+Write episode script from outline and cultural notes.
+
+**Input:**
+```json
+{
+  "approved_outline": "string",
+  "cultural_consultant_notes": "string",
+  "character_voice_guide": "string",
+  "character_list": ["Alex", "Jordan", "Casey", "Morgan"],
+  "story_premise": "string"
+}
+```
+
+**Output:**
+```json
+{
+  "full_episode_first_draft": "string",
+  "scene_descriptions": "string",
+  "dialogue": "string",
+  "stage_directions": "string"
+}
+```
+
+---
+
+### 5. Dialogue Specialist Agent
+```
+POST /api/agents/dialogue-specialist
+```
+Polish dialogue in the script.
+
+**Input:**
+```json
+{
+  "first_draft_script": "string (must not be empty)",
+  "character_voice_guide": "string",
+  "character_list": ["Alex", "Jordan", "Casey", "Morgan"],
+  "dialect_slang_reference": "string"
+}
+```
+
+**Output:**
+```json
+{
+  "dialogue_polished_script": "string",
+  "voice_consistency_notes": "string"
+}
+```
+
+---
+
+### 6. Comedy Writer Agent
+```
+POST /api/agents/comedy-writer
+```
+Add humor and punch-ups to the script.
+
+**Input:**
+```json
+{
+  "dialogue_polished_script": "string (must not be empty)",
+  "hook_brief_from_showrunner": "string",
+  "character_list": ["Alex", "Jordan", "Casey", "Morgan"],
+  "tone_brief": "string"
+}
+```
+
+**Output:**
+```json
+{
+  "comedy_sharpened_script": "string",
+  "punch_up_notes": "string",
+  "hook_rewrite_for_opening": "string"
+}
+```
+
+---
+
+### 7. Proofreader Agent
+```
+POST /api/agents/proofreader
+```
+Final quality control on the script.
+
+**Input:**
+```json
+{
+  "comedy_sharpened_script": "string (must not be empty)",
+  "style_guide": "string",
+  "continuity_log": "string",
+  "character_list": ["Alex", "Jordan", "Casey", "Morgan"]
+}
+```
+
+**Output:**
+```json
+{
+  "final_locked_script": "string",
+  "qc_report": {
+    "issues": [],
+    "style_alignment": "string",
+    "character_consistency": "string",
+    "formatting_notes": "string",
+    "recommendations": []
+  },
+  "continuity_log_update": "string"
+}
+```
+
+---
+
+## API Usage Examples
+
+### Example 1: Execute Full Pipeline
+```bash
+curl -X POST http://localhost:7860/api/pipeline/execute \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_brief": "A tech startup launches a new app",
+    "season_arc_document": "Season 1: The Rise",
+    "character_bible": "Alex (CEO), Jordan (CTO), Casey (Designer), Morgan (Marketer)",
+    "world_building_document": "Modern Silicon Valley",
+    "character_voice_guide": "Alex: sarcastic, Jordan: technical, Casey: perfectionist, Morgan: optimistic",
+    "style_guide": "Fast-paced, comedic, tech satire",
+    "continuity_log": "Episode 1: Team formation, Episode 2: First failure, Episode 3: Launch day"
+  }'
+```
+
+### Example 2: Call Individual Agent
+```bash
+curl -X POST http://localhost:7860/api/agents/showrunner \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_brief": "A tech startup launches a new app",
+    "season_arc_document": "Season 1: The Rise",
+    "character_bible": "Alex (CEO), Jordan (CTO), Casey (Designer), Morgan (Marketer)"
+  }'
+```
+
+### Example 3: Check Pipeline Status
+```bash
+curl -X GET http://localhost:7860/api/pipeline/status/0e35979c-8240-4451-a693-6bed1516aa4d
+```
+
+---
+
+## Error Handling
+
+All endpoints return appropriate HTTP status codes:
+
+- **200 OK** - Successful request
+- **400 Bad Request** - Invalid input
+- **404 Not Found** - Resource not found
+- **500 Internal Server Error** - Server error
+
+Error responses include a detail message:
+```json
+{
+  "detail": "Error message explaining what went wrong"
+}
+```
+
+---
+
+## Documentation
+
+- **Interactive API Docs:** `http://localhost:7860/docs` (Swagger UI)
+- **Alternative Docs:** `http://localhost:7860/redoc` (ReDoc)
+
+---
+
+## Architecture
+
+```
+Port 7860 (Single Port)
+├── /health
+├── /
+├── /api/pipeline/
+│   ├── execute
+│   └── status/{run_id}
+└── /api/agents/
+    ├── showrunner
+    ├── story-editor
+    ├── cultural-consultant
+    ├── lead-writer
+    ├── dialogue-specialist
+    ├── comedy-writer
+    └── proofreader
+```
+
+All agents communicate through the orchestrator and share state via the pipeline.

config.py

@@ -28,17 +28,19 @@ class Settings(BaseSettings):
     data_dir: str = "./data"
     output_dir: str = "./output"
     log_dir: str = "./logs"
-    port: int = 8000
+    port: int = 7860  # All agents run on this single port
     host: str = "0.0.0.0"
 
-    # Agent Ports
-    showrunner_port: int = 8001
-    story_editor_port: int = 8002
-    cultural_consultant_port: int = 8003
-    lead_writer_port: int = 8004
-    dialogue_specialist_port: int = 8005
-    comedy_writer_port: int = 8006
-    proofreader_port: int = 8007
+    # Agent Endpoints (all on port 7860)
+    # POST /api/agents/showrunner
+    # POST /api/agents/story-editor
+    # POST /api/agents/cultural-consultant
+    # POST /api/agents/lead-writer
+    # POST /api/agents/dialogue-specialist
+    # POST /api/agents/comedy-writer
+    # POST /api/agents/proofreader
+    # POST /api/pipeline/execute
+    # GET  /api/pipeline/status/{run_id}
 
     # Logging
     log_level: str = "INFO"
@@ -77,6 +79,7 @@ class Settings(BaseSettings):
         logger.info("Configuration loaded successfully")
         logger.info(f"Model: {self.model_name}")
         logger.info(f"Dataset: {self.huggingface_dataset}")
+        logger.info(f"Port: {self.port} (all agents on this single port)")
 
 
 # Load settings

main.py

@@ -1,4 +1,15 @@
-"""FastAPI server for the multi-agent content generation system."""
+"""FastAPI server for the multi-agent content generation system.
+
+All agents run on port 7860 with different API endpoints:
+- /api/agents/showrunner - Generate episode directive
+- /api/agents/story-editor - Generate episode outline
+- /api/agents/cultural-consultant - Review for cultural accuracy
+- /api/agents/lead-writer - Write episode script
+- /api/agents/dialogue-specialist - Polish dialogue
+- /api/agents/comedy-writer - Add humor and punch-ups
+- /api/agents/proofreader - Final quality control
+- /api/pipeline - Execute full pipeline
+"""
 import logging
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
@@ -17,7 +28,7 @@ logger = logging.getLogger(__name__)
 # Initialize FastAPI app
 app = FastAPI(
     title="Multi-Agent Content Generation System",
-    description="API-first system for collaborative content generation using poolside/laguna-m.1:free",
+    description="API-first system for collaborative content generation using poolside/laguna-m.1:free. All agents on port 7860.",
     version="1.0.0",
 )
 
@@ -51,21 +62,54 @@ class HealthResponse(BaseModel):
     """Health check response."""
     status: str
     run_id: str
+    port: int
 
 
-# Endpoints
+# ─────────────────────────────────────────────────────────────────────────────
+# HEALTH & STATUS ENDPOINTS
+# ─────────────────────────────────────────────────────────────────────────────
+
 @app.get("/health", response_model=HealthResponse)
 async def health_check():
     """Health check endpoint."""
     return {
         "status": "healthy",
         "run_id": orchestrator.run_id,
+        "port": settings.port,
+    }
+
+
+@app.get("/")
+async def root():
+    """Root endpoint with API documentation."""
+    return {
+        "service": "Multi-Agent Content Generation System",
+        "version": "1.0.0",
+        "port": settings.port,
+        "docs": "/docs",
+        "agents": {
+            "showrunner": "/api/agents/showrunner",
+            "story_editor": "/api/agents/story-editor",
+            "cultural_consultant": "/api/agents/cultural-consultant",
+            "lead_writer": "/api/agents/lead-writer",
+            "dialogue_specialist": "/api/agents/dialogue-specialist",
+            "comedy_writer": "/api/agents/comedy-writer",
+            "proofreader": "/api/agents/proofreader",
+        },
+        "pipeline": "/api/pipeline/execute",
     }
 
 
-@app.post("/api/v1/pipeline/execute", response_model=PipelineResponse)
+# ─────────────────────────────────────────────────────────────────────────────
+# PIPELINE ENDPOINTS (Port 7860)
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.post("/api/pipeline/execute", response_model=PipelineResponse)
 async def execute_pipeline(request: PipelineRequest):
     """Execute the full content generation pipeline.
+    
+    Endpoint: POST /api/pipeline/execute
+    Port: 7860
 
     Args:
         request: Pipeline execution request with all required inputs
@@ -74,7 +118,7 @@ async def execute_pipeline(request: PipelineRequest):
         Pipeline execution result with final output and URLs
     """
     try:
-        logger.info(f"Received pipeline execution request: {request.user_brief[:50]}...")
+        logger.info(f"[PIPELINE] Received execution request: {request.user_brief[:50]}...")
         
         result = orchestrator.execute_pipeline(
             user_brief=request.user_brief,
@@ -96,157 +140,241 @@ async def execute_pipeline(request: PipelineRequest):
         }
         
     except Exception as e:
-        logger.error(f"Pipeline execution error: {str(e)}")
+        logger.error(f"[PIPELINE] Execution error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post("/api/v1/showrunner/generate_directive")
-async def generate_directive(request: dict):
-    """Generate episode directive from user brief.
+@app.get("/api/pipeline/status/{run_id}")
+async def get_pipeline_status(run_id: str):
+    """Get the status of a pipeline run.
+    
+    Endpoint: GET /api/pipeline/status/{run_id}
+    Port: 7860
 
     Args:
-        request: Dictionary with user_brief, season_arc_document, character_bible
+        run_id: The run ID to check
 
     Returns:
-        Generated directive
+        Pipeline status and state
     """
     try:
-        result = orchestrator.showrunner.generate_directive(request)
-        return result
+        if run_id == orchestrator.run_id:
+            return {
+                "run_id": run_id,
+                "status": orchestrator.pipeline_state.get("status", "unknown"),
+                "pipeline_state": orchestrator.pipeline_state,
+            }
+        else:
+            raise HTTPException(status_code=404, detail="Run ID not found")
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post("/api/v1/story_editor/generate_outline")
-async def generate_outline(request: dict):
-    """Generate episode outline from directive.
-
-    Args:
-        request: Dictionary with episode_directive, series_continuity_log
+# ─────────────────────────────────────────────────────────────────────────────
+# AGENT ENDPOINTS (Port 7860)
+# ─────────────────────────────────────────────────────────────────────────────
 
-    Returns:
-        Generated outline
+@app.post("/api/agents/showrunner")
+async def showrunner_endpoint(request: dict):
+    """Showrunner Agent: Generate episode directive.
+    
+    Endpoint: POST /api/agents/showrunner
+    Port: 7860
+    
+    Input:
+        - user_brief: Initial user brief
+        - season_arc_document: Season context
+        - character_bible: Character definitions
+    
+    Output:
+        - episode_directive: Generated directive
+        - story_premise: Story premise
+        - tone_brief: Tone brief
+        - character_focus_notes: Character notes
     """
     try:
-        result = orchestrator.story_editor.generate_outline(request)
+        logger.info("[SHOWRUNNER] Processing directive generation")
+        result = orchestrator.showrunner.generate_directive(request)
         return result
     except Exception as e:
+        logger.error(f"[SHOWRUNNER] Error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post("/api/v1/cultural_consultant/review_outline")
-async def review_outline(request: dict):
-    """Review outline for cultural accuracy.
+@app.post("/api/agents/story-editor")
+async def story_editor_endpoint(request: dict):
+    """Story Editor Agent: Generate episode outline.
+    
+    Endpoint: POST /api/agents/story-editor
+    Port: 7860
+    
+    Input:
+        - episode_directive: From Showrunner
+        - series_continuity_log: Continuity reference
+        - character_list: Valid character names
+    
+    Output:
+        - episode_outline: Generated outline
+        - act_structure: Act breakdown
+        - story_notes_for_writers: Story notes
+    """
+    try:
+        logger.info("[STORY-EDITOR] Processing outline generation")
+        result = orchestrator.story_editor.generate_outline(request)
+        return result
+    except Exception as e:
+        logger.error(f"[STORY-EDITOR] Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-    Args:
-        request: Dictionary with episode_outline, world_building_document
 
-    Returns:
-        Cultural review and recommendations
+@app.post("/api/agents/cultural-consultant")
+async def cultural_consultant_endpoint(request: dict):
+    """Cultural Consultant Agent: Review for cultural accuracy.
+    
+    Endpoint: POST /api/agents/cultural-consultant
+    Port: 7860
+    
+    Input:
+        - episode_outline: From Story Editor
+        - world_building_document: World context
+        - character_list: Valid character names
+    
+    Output:
+        - cultural_accuracy_notes: Accuracy notes
+        - flagged_inaccuracies: Issues found
+        - approved_touchpoints: Approved elements
+        - reference_suggestions: Suggestions
     """
     try:
+        logger.info("[CULTURAL-CONSULTANT] Processing cultural review")
         result = orchestrator.cultural_consultant.review_outline(request)
         return result
     except Exception as e:
+        logger.error(f"[CULTURAL-CONSULTANT] Error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post("/api/v1/lead_writer/write_script")
-async def write_script(request: dict):
-    """Write episode script from outline and cultural notes.
-
-    Args:
-        request: Dictionary with approved_outline, cultural_consultant_notes, character_voice_guide
-
-    Returns:
-        Generated script
+@app.post("/api/agents/lead-writer")
+async def lead_writer_endpoint(request: dict):
+    """Lead Writer Agent: Write episode script.
+    
+    Endpoint: POST /api/agents/lead-writer
+    Port: 7860
+    
+    Input:
+        - approved_outline: From Story Editor
+        - cultural_consultant_notes: From Cultural Consultant
+        - character_voice_guide: Character voice definitions
+        - character_list: Valid character names
+        - story_premise: Story premise from Showrunner
+    
+    Output:
+        - full_episode_first_draft: Complete script
+        - scene_descriptions: Scene descriptions
+        - dialogue: Dialogue content
+        - stage_directions: Stage directions
     """
     try:
+        logger.info("[LEAD-WRITER] Processing script writing")
         result = orchestrator.lead_writer.write_script(request)
         return result
     except Exception as e:
+        logger.error(f"[LEAD-WRITER] Error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post("/api/v1/dialogue_specialist/polish_dialogue")
-async def polish_dialogue(request: dict):
-    """Polish dialogue in the script.
-
-    Args:
-        request: Dictionary with first_draft_script, character_voice_guide, dialect_slang_reference
-
-    Returns:
-        Polished script
+@app.post("/api/agents/dialogue-specialist")
+async def dialogue_specialist_endpoint(request: dict):
+    """Dialogue Specialist Agent: Polish dialogue.
+    
+    Endpoint: POST /api/agents/dialogue-specialist
+    Port: 7860
+    
+    Input:
+        - first_draft_script: From Lead Writer
+        - character_voice_guide: Character voice definitions
+        - character_list: Valid character names
+        - dialect_slang_reference: Reference material
+    
+    Output:
+        - dialogue_polished_script: Polished script
+        - voice_consistency_notes: Voice notes
     """
     try:
+        logger.info("[DIALOGUE-SPECIALIST] Processing dialogue polish")
         result = orchestrator.dialogue_specialist.polish_dialogue(request)
         return result
     except Exception as e:
+        logger.error(f"[DIALOGUE-SPECIALIST] Error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post("/api/v1/comedy_writer/add_humor")
-async def add_humor(request: dict):
-    """Add humor and punch-ups to the script.
-
-    Args:
-        request: Dictionary with dialogue_polished_script, hook_brief_from_showrunner
-
-    Returns:
-        Comedy-enhanced script
+@app.post("/api/agents/comedy-writer")
+async def comedy_writer_endpoint(request: dict):
+    """Comedy Writer Agent: Add humor and punch-ups.
+    
+    Endpoint: POST /api/agents/comedy-writer
+    Port: 7860
+    
+    Input:
+        - dialogue_polished_script: From Dialogue Specialist
+        - hook_brief_from_showrunner: Hook context
+        - character_list: Valid character names
+        - tone_brief: Tone reference
+    
+    Output:
+        - comedy_sharpened_script: Comedy-enhanced script
+        - punch_up_notes: Notes on changes
+        - hook_rewrite_for_opening: Opening hook
     """
     try:
+        logger.info("[COMEDY-WRITER] Processing humor addition")
         result = orchestrator.comedy_writer.add_humor(request)
         return result
     except Exception as e:
+        logger.error(f"[COMEDY-WRITER] Error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post("/api/v1/proofreader/final_qc")
-async def final_qc(request: dict):
-    """Perform final quality control on the script.
-
-    Args:
-        request: Dictionary with comedy_sharpened_script, style_guide, continuity_log
-
-    Returns:
-        Final QC report and locked script
+@app.post("/api/agents/proofreader")
+async def proofreader_endpoint(request: dict):
+    """Proofreader Agent: Final quality control.
+    
+    Endpoint: POST /api/agents/proofreader
+    Port: 7860
+    
+    Input:
+        - comedy_sharpened_script: From Comedy Writer
+        - style_guide: Style reference
+        - continuity_log: Continuity tracking
+        - character_list: Valid character names
+    
+    Output:
+        - final_locked_script: Final script
+        - qc_report: Quality control report
+        - continuity_log_update: Updated continuity log
     """
     try:
+        logger.info("[PROOFREADER] Processing final QC")
         result = orchestrator.proofreader.final_qc(request)
         return result
     except Exception as e:
+        logger.error(f"[PROOFREADER] Error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.get("/api/v1/pipeline/status/{run_id}")
-async def get_pipeline_status(run_id: str):
-    """Get the status of a pipeline run.
-
-    Args:
-        run_id: The run ID to check
-
-    Returns:
-        Pipeline status and state
-    """
-    try:
-        # In a real system, this would query a database
-        # For now, we return the current orchestrator state if it matches
-        if run_id == orchestrator.run_id:
-            return {
-                "run_id": run_id,
-                "status": orchestrator.pipeline_state.get("status", "unknown"),
-                "pipeline_state": orchestrator.pipeline_state,
-            }
-        else:
-            raise HTTPException(status_code=404, detail="Run ID not found")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
+# ──────────────────────────────────────────────────────────���──────────────────
+# SERVER STARTUP
+# ─────────────────────────────────────────────────────────────────────────────
 
 if __name__ == "__main__":
     import uvicorn
     
+    logger.info(f"Starting Multi-Agent System on port {settings.port}")
+    logger.info("All agents available at http://localhost:7860/api/agents/*")
+    logger.info("Full pipeline available at http://localhost:7860/api/pipeline/execute")
+    logger.info("API documentation at http://localhost:7860/docs")
+    
     uvicorn.run(
         app,
         host=settings.host,