diff --git a/examples/Vibe_Agent_Builder_gpt_5/README.md b/examples/Vibe_Agent_Builder_gpt_5/README.md
new file mode 100644
index 0000000..12ec842
--- /dev/null
+++ b/examples/Vibe_Agent_Builder_gpt_5/README.md
@@ -0,0 +1,353 @@
+# RunAgent Generator
+
+RunAgent Generator is an intelligent system that automatically creates custom AI agents based on natural language descriptions. Using GPT-5 for analysis and code generation, it supports multiple AI frameworks and provides a complete development environment for AI agents.
+
+## User Interface
+
+| Agent Builder Interface | Agent Testing Interface |
+|:-----------------------:|:-----------------------:|
+| ![Agent Builder UI](image/agent-builder-ui.png) | ![Agent Testing UI](image/agent-ui.png) |
+| Create agents through natural language | Test and interact with generated agents |
+
+## Overview
+
+The system analyzes user requirements in natural language and generates complete, working AI agents with:
+- Framework-specific code (LangGraph, Letta, Agno, LlamaIndex, or custom)
+- Configuration files and dependencies
+- Test scripts and SDK integration
+- Web interfaces for testing and interaction
+- Automatic server deployment
+
+## Features
+
+### Core Capabilities
+- **Natural Language Processing**: Describe your agent requirements in plain English
+- **Multi-Framework Support**: Generate agents for LangGraph, Letta, Agno, LlamaIndex, or custom frameworks
+- **Intelligent Framework Selection**: Automatically chooses the best framework based on requirements
+- **Dynamic Input Configuration**: Creates custom input fields based on agent functionality
+- **Real-time Code Generation**: Uses GPT-5 to generate production-ready code
+- **Workflow Visualization**: Generates Mermaid diagrams showing agent workflows
+- **Complete Project Setup**: Includes all necessary files, dependencies, and configurations
+
+### Web Interfaces
+- **Agent Builder Interface**: Interactive chat-based agent creation
+- **Agent Testing Interface**: Comprehensive testing environment with streaming support
+- **Multi-session Management**: Handle multiple agent creation sessions simultaneously
+- **Responsive Design**: Works on desktop and mobile devices
+
+### Testing & Deployment
+- **Automatic Server Deployment**: Starts RunAgent servers for generated agents
+- **Python SDK Integration**: Generates test scripts using the RunAgent Python SDK
+- **Streaming Support**: Tests both synchronous and streaming agent responses
+- **Live Testing**: Real-time agent testing with streaming output
+- **Debug Endpoints**: Built-in debugging tools for troubleshooting
+
+## Architecture
+
+### System Overview
+
+```mermaid
+graph TD
+    A[User Input: Natural Language Description] --> B[GPT-5 Analysis Engine]
+    B --> C[Framework Selection]
+    C --> D[Code Generation]
+    D --> E[Project Files Created]
+    E --> F[RunAgent Configuration]
+    F --> G[RunAgent Server Deployment]
+    G --> H[Agent Testing Interface]
+    H --> I[RunAgent SDK Client]
+    I --> J[Live Agent Interaction]
+    
+    K[Multiple Frameworks] --> C
+    K --> L[LangGraph]
+    K --> M[Letta]  
+    K --> N[Agno]
+    K --> O[LlamaIndex]
+    K --> P[Custom]
+    
+    style A fill:#e1f5fe
+    style B fill:#f3e5f5
+    style G fill:#e8f5e8
+    style F fill:#e8f5e8
+    style I fill:#e8f5e8
+```
+
+### Components
+1. **FastAPI Backend** (`main.py`): Core API server handling agent generation and management
+2. **Agent Builder UI** (`index.html`): Web interface for creating agents through natural language
+3. **Agent Testing UI** (`agent.html`): Interface for testing and interacting with generated agents
+4. **Test SDK** (`test_sdk.py`): Python script for testing agents via SDK
+
+### Workflow
+1. **Request Analysis**: GPT-5 analyzes user requirements and extracts agent specifications
+2. **Framework Selection**: System chooses optimal framework based on requirements
+3. **Code Generation**: Generates framework-specific agent code and configurations
+4. **Project Creation**: Creates complete project structure with all necessary files
+5. **RunAgent Integration**: Creates RunAgent configuration and deployment files
+6. **Server Deployment**: Automatically starts RunAgent server for the new agent
+7. **Testing Interface**: Provides web interface for immediate agent testing via RunAgent SDK
+
+### RunAgent Integration
+
+RunAgent serves as the deployment and interaction layer for generated agents:
+
+- **Configuration Generation**: Each agent gets a `runagent.config.json` file specifying entrypoints, input schemas, and environment requirements
+- **Server Deployment**: Generated agents are automatically deployed using `runagent serve` command
+- **SDK Integration**: Test scripts and web interfaces use `RunAgentClient` for seamless agent interaction
+- **Multi-Entrypoint Support**: Agents support both synchronous and streaming endpoints through RunAgent's architecture
+- **Local Development**: All agents run locally with RunAgent handling server management and client connections
+
+## Installation
+
+### Prerequisites
+- Python 3.8 or higher
+- OpenAI API key with GPT-5 access
+- RunAgent SDK installed (`pip install runagent`)
+
+### Setup
+1. **Clone or download the project files**
+2. **Install dependencies**:
+   ```bash
+   pip install fastapi uvicorn openai pathlib shutil subprocess threading
+   ```
+3. **Set environment variables**:
+   ```bash
+   export OPENAI_API_KEY="your-gpt-5-api-key"
+   ```
+4. **Create required directories**:
+   ```bash
+   mkdir generated_agents static
+   ```
+5. **Add static assets** (optional):
+   - Add `icon.png` to the `static/` directory for UI branding
+
+## Usage
+
+### Starting the Server
+```bash
+python main.py
+```
+The server will start on `http://localhost:8000`
+
+### Creating Agents
+
+#### Web Interface
+1. Navigate to `http://localhost:8000/static/index.html`
+2. Describe your agent requirements in natural language
+3. Review the generated agent plan and workflow diagram
+4. Confirm generation to create the agent
+5. Access the agent through the provided interface URL
+
+#### Example Requests
+- "Create a weather agent that takes a location and returns current conditions using LangGraph"
+- "Build a math solver that can solve equations step by step with Agno"
+- "Make a research assistant that can search and summarize information using LlamaIndex"
+- "I want a content writer agent that takes a topic and style and generates articles"
+
+#### API Endpoint
+```bash
+curl -X POST "http://localhost:8000/chat" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "Create a weather agent using LangGraph",
+    "session_id": "optional-session-id"
+  }'
+```
+
+### Testing Agents
+
+#### Web Interface
+1. Use the agent URL provided after generation
+2. Configure input fields based on your agent's requirements
+3. Test with both synchronous and streaming modes
+4. View detailed results and debug information
+
+#### Python SDK Testing
+```bash
+python test_sdk.py <agent_id> <port>
+```
+
+#### Manual Testing Script
+Each generated agent includes an `agent_test.py` script:
+```bash
+cd generated_agents/<session_id>/
+python agent_test.py <agent_id> localhost <port> "test message"
+```
+
+## Generated Project Structure
+
+Each generated agent creates a complete project:
+
+```
+generated_agents/<session_id>/
+├── agent.py                 # Main agent code
+├── requirements.txt         # Python dependencies
+├── runagent.config.json    # RunAgent configuration
+├── agent_test.py           # SDK test script
+├── .env                    # Environment variables
+└── README.md               # Agent documentation
+```
+
+### Configuration Files
+
+#### runagent.config.json
+- Agent metadata and description
+- Framework and template information
+- Input field specifications and types
+- Entrypoint configurations
+- Environment variable requirements
+
+#### requirements.txt
+- Framework-specific dependencies
+- Version specifications
+- Additional libraries as needed
+
+## API Reference
+
+### Core Endpoints
+
+#### POST /chat
+Create or continue agent generation conversation
+- **Body**: `{"message": "string", "session_id": "optional"}`
+- **Response**: Chat response with stage information and agent data
+
+#### GET /agent/{agent_id}
+Retrieve comprehensive agent information
+- **Response**: Agent configuration, status, and connection details
+
+#### GET /agent/{agent_id}/run-test
+Execute agent test with custom inputs
+- **Query Params**: `test_message`, `input_data`, `streaming`, `entrypoint_tag`
+- **Response**: Test results and agent output
+
+#### GET /agent/{agent_id}/run-test-stream
+Live streaming test with real-time output
+- **Query Params**: `test_message`, `input_data`, `entrypoint_tag`
+- **Response**: Server-sent events with streaming output
+
+### Debug Endpoints
+
+#### GET /agent/{agent_id}/sdk
+Download generated Python test script
+
+#### GET /debug/test-agent/{agent_id}
+Debug agent functionality with multiple endpoint tests
+
+#### GET /debug/clear-sessions
+Clear all active sessions and agents (development only)
+
+#### GET /health
+Server health check
+
+## Configuration
+
+### Environment Variables
+- `OPENAI_API_KEY`: Required for GPT-5 access
+- `RUNAGENT_LOG_LEVEL`: Logging level (default: INFO)
+- `RUNAGENT_DISABLE_DB`: Disable database features (set to 'true')
+
+### Agent Input Configuration
+Agents automatically configure input fields based on requirements:
+- **Dynamic Field Generation**: Creates appropriate input fields for agent functionality
+- **Type Validation**: Supports string, number, boolean, array, email, URL types
+- **Default Values**: Provides sensible defaults for non-primary fields
+- **Descriptions**: Generates helpful descriptions for each input field
+
+## Development
+
+### Extending Framework Support
+To add support for a new framework:
+1. Create a new `generate_[framework]_files()` function in `main.py`
+2. Update the framework selection logic in `analyze_user_request()`
+3. Add framework-specific dependencies and configuration templates
+
+### Customizing Agent Templates
+Agent templates can be customized by modifying the generation functions:
+- Update code templates for different agent behaviors
+- Modify configuration schemas for new input types
+- Add framework-specific features and capabilities
+
+### Adding New Features
+- **UI Enhancements**: Modify `index.html` and `agent.html` for interface improvements
+- **API Extensions**: Add new endpoints in `main.py` for additional functionality
+- **Testing Tools**: Extend `test_sdk.py` and generated test scripts
+
+## Troubleshooting
+
+### Common Issues
+
+#### Agent Generation Fails
+- Verify OpenAI API key is set and has GPT-5 access
+- Check that all required dependencies are installed
+- Ensure sufficient disk space for generated files
+
+#### Agent Server Won't Start
+- Verify RunAgent SDK is installed: `pip install runagent`
+- Check that ports are not already in use
+- Review generated requirements.txt for missing dependencies
+
+#### Agent Tests Fail
+- Confirm agent server is running on expected port
+- Verify input field names match agent configuration
+- Check entrypoint tags are correctly specified
+
+#### Streaming Tests Timeout
+- Increase timeout values in test scripts
+- Verify agent supports streaming entrypoints
+- Check network connectivity to agent server
+
+### Debug Information
+Use the debug endpoints to gather troubleshooting information:
+- `/debug/test-agent/{agent_id}` for comprehensive agent testing
+- `/health` for server status
+- Check browser console for JavaScript errors in web interfaces
+
+### Log Analysis
+Server logs provide detailed information about:
+- Agent generation process
+- Framework selection reasoning
+- Server startup and configuration
+- Error messages and stack traces
+
+## Performance Considerations
+
+### Resource Usage
+- Each agent runs in its own RunAgent server process
+- Memory usage scales with number of active agents
+- Generated agents include efficient resource management
+
+### Optimization Tips
+- Limit concurrent agent generation requests
+- Clean up unused agent sessions periodically
+- Monitor system resources when running multiple agents
+- Use appropriate framework selection for performance requirements
+
+## Security Notes
+
+### API Key Management
+- Store OpenAI API keys securely
+- Use environment variables for sensitive configuration
+- Implement rate limiting for production deployments
+
+### Generated Code Security
+- Review generated agent code before deployment
+- Validate input fields and types in production
+- Implement appropriate access controls for agent endpoints
+
+### Network Security
+- Run on private networks when possible
+- Use HTTPS in production environments
+- Implement authentication for sensitive agents
+
+## Contributing
+
+When contributing to this project:
+1. Follow existing code structure and patterns
+2. Add comprehensive error handling
+3. Update documentation for new features
+4. Test with multiple frameworks and configurations
+5. Consider backward compatibility for existing agents
+
+## License
+
+This project is provided as-is for educational and development purposes. Ensure compliance with OpenAI's terms of service when using GPT-5 for agent generation.
\ No newline at end of file
diff --git a/examples/Vibe_Agent_Builder_gpt_5/image/agent-builder-ui.png b/examples/Vibe_Agent_Builder_gpt_5/image/agent-builder-ui.png
new file mode 100644
index 0000000..87bc7db
Binary files /dev/null and b/examples/Vibe_Agent_Builder_gpt_5/image/agent-builder-ui.png differ
diff --git a/examples/Vibe_Agent_Builder_gpt_5/image/agent-ui.png b/examples/Vibe_Agent_Builder_gpt_5/image/agent-ui.png
new file mode 100644
index 0000000..6388e5b
Binary files /dev/null and b/examples/Vibe_Agent_Builder_gpt_5/image/agent-ui.png differ
diff --git a/examples/Vibe_Agent_Builder_gpt_5/image/graph.png b/examples/Vibe_Agent_Builder_gpt_5/image/graph.png
new file mode 100644
index 0000000..e32575d
Binary files /dev/null and b/examples/Vibe_Agent_Builder_gpt_5/image/graph.png differ
diff --git a/examples/Vibe_Agent_Builder_gpt_5/main.py b/examples/Vibe_Agent_Builder_gpt_5/main.py
new file mode 100644
index 0000000..65059c5
--- /dev/null
+++ b/examples/Vibe_Agent_Builder_gpt_5/main.py
@@ -0,0 +1,2091 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import Response
+from pydantic import BaseModel
+import os
+import json
+import uuid
+import subprocess
+import threading
+import time
+from typing import Dict, List, Optional
+from openai import OpenAI
+import shutil
+from pathlib import Path
+
+app = FastAPI(title="RunAgent Generator API")
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Serve static files
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Initialize OpenAI client
+openai_client = OpenAI()
+
+# In-memory storage for sessions and running agents
+sessions: Dict[str, dict] = {}
+running_agents: Dict[str, dict] = {}
+
+class ChatRequest(BaseModel):
+    message: str
+    session_id: Optional[str] = None
+
+class ChatResponse(BaseModel):
+    response: str
+    session_id: str
+    stage: str  # "understanding", "planning", "generating", "complete"
+    description: Optional[str] = None
+    mermaid_diagram: Optional[str] = None
+    agent_id: Optional[str] = None
+    agent_url: Optional[str] = None
+    sdk_config: Optional[dict] = None  # New field for SDK configuration
+
+def analyze_user_request(message: str) -> dict:
+    """Use GPT-5 to analyze user request and extract agent requirements."""
+    
+    prompt = f"""
+    Analyze this user request for creating an AI agent: "{message}"
+    
+    Extract and return a JSON with:
+    1. agent_name: A concise name for the agent (snake_case, no spaces)
+    2. framework: One of [langgraph, letta, agno, llamaindex] 
+    3. template_type: "basic" or "advanced"
+    4. description: What the agent does (2-3 sentences)
+    5. main_functionality: Primary purpose (concise)
+    6. input_fields: List of input field names the agent needs (e.g., ["query", "max_results"])
+    7. input_types: Object mapping field names to types (e.g., {{"query": "string", "max_results": "number"}})
+    8. input_descriptions: Object mapping field names to descriptions
+    9. expected_output_format: Description of what the agent returns
+    10. example_inputs: List of example input objects
+    11. backend_language: "python" or "typescript" (default python unless specified)
+    12. entrypoint_tags: List of entrypoint tags (e.g., ["main", "main_stream"])
+    
+    Choose framework based on:
+    - langgraph: Complex workflows, multi-agent systems, decision trees
+    - letta: Conversational AI, memory-based agents, chat interfaces  
+    - agno: Simple assistants, analysis tasks, reporting
+    - llamaindex: RAG, document processing, knowledge retrieval
+    
+    Make input_fields specific to the use case. For example:
+    - Weather agent: ["location", "units"]
+    - Math solver: ["expression", "show_steps"]
+    - Research agent: ["topic", "depth", "sources"]
+    - Content writer: ["topic", "style", "length"]
+    
+    Return only valid JSON.
+    """
+    
+    try:
+        response = openai_client.responses.create(
+            model="gpt-5-mini",
+            input=prompt,
+            reasoning={"effort": "minimal"}
+        )
+        
+        content = response.output[1].content[0].text
+        result = json.loads(content)
+        
+        # Ensure required fields have defaults
+        result.setdefault("input_fields", ["query"])
+        result.setdefault("input_types", {"query": "string"})
+        result.setdefault("input_descriptions", {"query": "User input"})
+        result.setdefault("entrypoint_tags", ["main", "main_stream"])
+        result.setdefault("expected_output_format", "String response")
+        result.setdefault("example_inputs", [{"query": "Hello, how can you help me?"}])
+        
+        return result
+    except Exception as e:
+        print(f"Error analyzing request: {e}")
+        return {
+            "agent_name": "custom_agent",
+            "framework": "agno",
+            "template_type": "basic", 
+            "description": "A custom AI agent",
+            "main_functionality": "General assistance",
+            "input_fields": ["query"],
+            "input_types": {"query": "string"},
+            "input_descriptions": {"query": "User input"},
+            "expected_output_format": "String response",
+            "example_inputs": [{"query": "Hello"}],
+            "entrypoint_tags": ["main", "main_stream"],
+            "backend_language": "python"
+        }
+def generate_agent_test_script(agent_info: dict, session_dir: Path):
+    """Generate agent test script with proper buffering support"""
+    
+    primary_field = agent_info['input_fields'][0] if agent_info['input_fields'] else 'query'
+    
+    # Create input preparation logic
+    input_assignments = [f'    input_data["{primary_field}"] = test_message']
+    
+    # Add other fields with appropriate defaults
+    for field in agent_info['input_fields'][1:]:
+        field_type = agent_info['input_types'].get(field, 'string')
+        if field_type in ['number', 'integer']:
+            default_value = '1'
+        elif field_type == 'boolean':
+            default_value = 'True'
+        elif field_type in ['array', 'list']:
+            default_value = '[]'
+        else:
+            default_value = f'"short"' if 'length' in field else f'"default"'
+        
+        input_assignments.append(f'    input_data["{field}"] = {default_value}')
+    
+    input_prep = '\n'.join(input_assignments)
+    
+    fixed_script = f'''import sys
+import time
+import json
+from runagent import RunAgentClient
+
+def main():
+    if len(sys.argv) != 5:
+        print("Usage: python3 agent_test.py <agent_id> <host> <port> <test_message>")
+        print("Example: python3 agent_test.py abc123 localhost 8450 'Hello'")
+        sys.exit(1)
+    
+    agent_id = sys.argv[1]
+    host = sys.argv[2] 
+    port = int(sys.argv[3])
+    test_message = sys.argv[4]
+    
+    print(f"Testing Agent: {{agent_id}}")
+    print(f"Connection: {{host}}:{{port}}")
+    print(f"Test Message: {{test_message}}")
+    print(f"Framework: {agent_info['framework']}")
+    print("=" * 60)
+    
+    # Prepare input data based on agent configuration
+    input_data = {{}}
+{input_prep}
+    
+    print(f"Prepared inputs for agent: {{json.dumps(input_data, indent=2)}}")
+    print(f"Connecting to service at {{host}}:{{port}} ...")
+    
+    # Test each entrypoint tag in order
+    entrypoints = {agent_info['entrypoint_tags']}
+    
+    for i, tag in enumerate(entrypoints, 1):
+        try:
+            print(f"\\nAttempt {{i}}/{{len(entrypoints)}}: Testing entrypoint '{{tag}}'")
+            start_time = time.time()
+            
+            # Create RunAgentClient
+            ra = RunAgentClient(
+                agent_id=agent_id,
+                entrypoint_tag=tag,
+                local=True
+            )
+            
+            print(f"Client created successfully")
+            
+            # Test the agent
+            if "stream" in tag.lower():
+                print("Testing streaming mode:")
+                print("-" * 40)
+                chunk_count = 0
+                
+                try:
+                    for chunk in ra.run(**input_data):
+                        chunk_count += 1
+                        print(chunk)
+                        
+                        if chunk_count > 100:  # Prevent infinite loops
+                            print("\\n... [truncated after 100 chunks]")
+                            break
+                            
+                except Exception as stream_error:
+                    print(f"\\nStreaming error: {{stream_error}}")
+                    continue
+                    
+                print(f"\\n-" * 40)
+                print(f"Received {{chunk_count}} chunks")
+            else:
+                print("Testing synchronous mode:")
+                result = ra.run(**input_data)
+                print(f"Result Type: {{type(result)}}")
+                print(f"Result Content:")
+                if isinstance(result, dict):
+                    if 'content' in result:
+                        print(result['content'])
+                    else:
+                        print(json.dumps(result, indent=2, default=str))
+                else:
+                    result_str = str(result)
+                    print(result_str[:500] + "..." if len(result_str) > 500 else result_str)
+            
+            elapsed = time.time() - start_time
+            print(f"\\nExecution Time: {{elapsed:.2f}} seconds")
+            print(f"SUCCESS! Agent responded via entrypoint '{{tag}}'")
+            sys.exit(0)
+            
+        except Exception as e:
+            print(f"Failed with entrypoint '{{tag}}': {{str(e)}}")
+            if i < len(entrypoints):
+                print("Trying next entrypoint...")
+            continue
+    
+    print(f"\\nAll {{len(entrypoints)}} entrypoints failed!")
+    print("Troubleshooting tips:")
+    print("   - Verify the agent is running at the specified host:port")
+    print("   - Check that agent_id is correct")
+    print("   - Ensure RunAgent is installed: pip install runagent")
+    print("   - Try different entrypoint tags manually")
+    sys.exit(1)
+
+if __name__ == "__main__":
+    main()
+'''
+    
+    with open(session_dir / "agent_test.py", "w") as f:
+        f.write(fixed_script)
+    
+    # Make it executable
+    import stat
+    script_path = session_dir / "agent_test.py"
+    script_path.chmod(script_path.stat().st_mode | stat.S_IEXEC)
+    
+    print(f"Generated fixed agent test script for {agent_info['agent_name']}")
+    print(f"Script location: {script_path}")
+    return True
+
+
+def generate_mermaid_diagram(agent_info: dict) -> str:
+    """Generate dynamic Mermaid diagram using GPT-5"""
+    
+    prompt = f"""
+    Create a valid Mermaid flowchart diagram for an AI agent:
+    
+    Agent Name: {agent_info['agent_name']}
+    Framework: {agent_info['framework']}
+    Description: {agent_info['description']}
+    Main Functionality: {agent_info['main_functionality']}
+    Input Fields: {agent_info['input_fields']}
+    
+    REQUIREMENTS:
+    1. Start with "graph TD"
+    2. Use simple node IDs (A, B, C, etc.)
+    3. Use only basic shapes: [text], {{text}}, ((text))
+    4. Use only --> arrows
+    5. Keep node text under 20 characters
+    6. Maximum 8 nodes total
+    7. Show the specific workflow for this agent type
+    
+    Return ONLY the Mermaid code.
+    """
+    
+    try:
+        response = openai_client.responses.create(
+            model="gpt-5-mini",
+            input=prompt,
+            reasoning={"effort": "minimal"}
+        )
+        
+        mermaid_code = response.output[1].content[0].text.strip()
+        mermaid_code = mermaid_code.replace('```mermaid', '').replace('```', '').strip()
+        
+        lines = [line.strip() for line in mermaid_code.split('\n') if line.strip()]
+        mermaid_code = '\n    '.join(lines)
+        
+        if not mermaid_code.startswith(('graph TD', 'graph LR')):
+            mermaid_code = f"graph TD\n    {mermaid_code}"
+        
+        return mermaid_code
+        
+    except Exception as e:
+        print(f"❌ Error generating Mermaid diagram: {e}")
+        return f"graph TD\n    A[User Input] --> B[{agent_info['framework']} Processing]\n    B --> C[Generate Response]\n    C --> D[Return Result]"
+
+
+def generate_langgraph_files(agent_info: dict, session_dir: Path):
+    """Generate LangGraph agent files with proper input handling."""
+    
+    input_fields_str = json.dumps(agent_info['input_fields'])
+    input_types_str = json.dumps(agent_info['input_types'])
+    
+    agent_code = f'''"""
+{agent_info['agent_name']} - {agent_info['description']}
+Generated by RunAgent Generator
+"""
+
+from typing import List, TypedDict, Any
+from langchain_core.messages import HumanMessage
+from langchain_openai import ChatOpenAI
+from langgraph.graph import END, StateGraph
+
+class AgentState(TypedDict):
+    input_data: dict
+    result: str
+
+llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)
+
+def process_agent(state: AgentState) -> AgentState:
+    """Main processing function for {agent_info['agent_name']}"""
+    
+    input_data = state.get('input_data', {{}})
+    
+    # Extract relevant inputs
+    extracted_info = []
+    for field in {input_fields_str}:
+        if field in input_data:
+            extracted_info.append(f"{{field}}: {{input_data[field]}}")
+    
+    input_summary = "\\n".join(extracted_info) if extracted_info else "No specific input provided"
+    
+    prompt = f"""
+    {agent_info['description']}
+    
+    Main functionality: {agent_info['main_functionality']}
+    
+    User input:
+    {{input_summary}}
+    
+    Please provide a helpful response based on this agent's purpose.
+    """
+    
+    response = llm.invoke([HumanMessage(content=prompt)])
+    
+    return {{**state, "result": response.content}}
+
+def create_workflow():
+    """Create the agent workflow"""
+    workflow = StateGraph(AgentState)
+    
+    workflow.add_node("process", process_agent)
+    workflow.set_entry_point("process") 
+    workflow.add_edge("process", END)
+    
+    return workflow.compile()
+
+# Create workflow
+app = create_workflow()
+
+def main(*input_args, **input_kwargs):
+    """Main entry point for RunAgent (standard)"""
+    
+    # Run the workflow
+    result = app.invoke({{
+        "input_data": input_kwargs,
+        "result": ""
+    }})
+    
+    return result["result"]
+
+def main_stream(*input_args, **input_kwargs):
+    """Streaming entry point"""
+    
+    try:
+        for chunk in app.stream({{
+            "input_data": input_kwargs,
+            "result": ""
+        }}):
+            if "result" in chunk.get("process", {{}}):
+                yield chunk["process"]["result"]
+            else:
+                yield str(chunk)
+    except Exception as e:
+        yield f"Error: {{str(e)}}"
+'''
+    
+    # Write agent file
+    with open(session_dir / "agent.py", "w") as f:
+        f.write(agent_code)
+    
+    # Generate requirements.txt
+    requirements = """langgraph>=0.0.65
+langchain>=0.1.0
+langchain-core>=0.1.0
+langchain-openai>=0.0.5
+"""
+    
+    with open(session_dir / "requirements.txt", "w") as f:
+        f.write(requirements)
+    
+    # Generate runagent.config.json
+    config = {
+        "agent_name": agent_info['agent_name'],
+        "description": agent_info['description'],
+        "framework": "langgraph",
+        "template": "custom",
+        "version": "1.0.0",
+        "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "template_source": {
+            "repo_url": "https://github.com/runagent-dev/runagent.git",
+            "path": "generated/custom",
+            "author": "runagent-generator",
+            "version": "1.0.0"
+        },
+        "agent_architecture": {
+            "entrypoints": [
+                {
+                    "file": "agent.py",
+                    "module": "main",
+                    "tag": "main"
+                },
+                {
+                    "file": "agent.py", 
+                    "module": "main_stream",
+                    "tag": "main_stream"
+                }
+            ]
+        },
+        "input_fields": agent_info['input_fields'],
+        "input_types": agent_info['input_types'],
+        "input_descriptions": agent_info['input_descriptions'],
+        "env_vars": {
+            "OPENAI_API_KEY": "${OPENAI_API_KEY}"
+        }
+    }
+    
+    with open(session_dir / "runagent.config.json", "w") as f:
+        json.dump(config, f, indent=2)
+
+def generate_agno_files(agent_info: dict, session_dir: Path):
+    """Generate Agno agent files with proper input handling."""
+    
+    input_fields_str = json.dumps(agent_info['input_fields'])
+    
+    agent_code = f'''from functools import partial
+from agno.agent import Agent
+from agno.models.openai import OpenAIChat
+
+agent = Agent(
+    model=OpenAIChat(id="gpt-4o-mini"),
+    description="{agent_info['description']}",
+    instructions="Focus on: {agent_info['main_functionality']}",
+    markdown=True
+)
+
+def agent_run(*input_args, **input_kwargs):
+    """Main agent function"""
+    
+    # Extract input from various sources
+    input_parts = []
+    for field in {input_fields_str}:
+        if input_kwargs.get(field):
+            input_parts.append(f"{{field}}: {{input_kwargs[field]}}")
+    
+    if not input_parts and input_args:
+        input_parts.append(f"Input: {{str(input_args[0])}}")
+    
+    if not input_parts:
+        input_parts.append("No specific input provided")
+    
+    user_input = "\\n".join(input_parts)
+    
+    # Add context about the agent's purpose
+    full_prompt = f"""
+    {agent_info['description']}
+    
+    User input:
+    {{user_input}}
+    
+    Please provide a helpful response focused on: {agent_info['main_functionality']}
+    """
+    
+    response = agent.run(full_prompt)
+    
+    return {{
+        "content": response.content if hasattr(response, 'content') else str(response),
+    }}
+
+def agent_run_stream(*input_args, **input_kwargs):
+    """Streaming agent function"""
+    
+    input_parts = []
+    for field in {input_fields_str}:
+        if input_kwargs.get(field):
+            input_parts.append(f"{{field}}: {{input_kwargs[field]}}")
+    
+    if not input_parts and input_args:
+        input_parts.append(f"Input: {{str(input_args[0])}}")
+    
+    if not input_parts:
+        input_parts.append("No specific input provided")
+    
+    user_input = "\\n".join(input_parts)
+    
+    full_prompt = f"""
+    {agent_info['description']}
+    
+    User input:
+    {{user_input}}
+    
+    Please provide a helpful response focused on: {agent_info['main_functionality']}
+    """
+    
+    for chunk in agent.run(full_prompt, stream=True):
+        yield {{
+            "content": chunk.content if hasattr(chunk, 'content') else str(chunk)
+        }}
+'''
+    
+    with open(session_dir / "agent.py", "w") as f:
+        f.write(agent_code)
+    
+    # Generate requirements
+    with open(session_dir / "requirements.txt", "w") as f:
+        f.write("agno>=1.7.2\n")
+    
+    # Generate config
+    config = {
+        "agent_name": agent_info['agent_name'],
+        "description": agent_info['description'],
+        "framework": "agno",
+        "template": "custom",
+        "version": "1.0.0",
+        "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "template_source": {
+            "repo_url": "https://github.com/runagent-dev/runagent.git",
+            "path": "generated/custom",
+            "author": "runagent-generator",
+            "version": "1.0.0"
+        },
+        "agent_architecture": {
+            "entrypoints": [
+                {
+                    "file": "agent.py",
+                    "module": "agent_run",
+                    "tag": "main",
+                    "extractor": {"content": "$.content"}
+                },
+                {
+                    "file": "agent.py",
+                    "module": "agent_run_stream", 
+                    "tag": "main_stream",
+                    "extractor": {"content": "$.content"}
+                }
+            ]
+        },
+        "input_fields": agent_info['input_fields'],
+        "input_types": agent_info['input_types'],
+        "input_descriptions": agent_info['input_descriptions'],
+        "env_vars": {
+            "OPENAI_API_KEY": "${OPENAI_API_KEY}"
+        }
+    }
+    
+    with open(session_dir / "runagent.config.json", "w") as f:
+        json.dump(config, f, indent=2)
+
+def generate_letta_files(agent_info: dict, session_dir: Path):
+    """Generate Letta agent files with proper input handling."""
+    
+    input_fields_str = json.dumps(agent_info['input_fields'])
+    
+    agent_code = f'''import os
+from typing import Any
+from dotenv import load_dotenv
+from letta_client import CreateBlock, Letta
+
+load_dotenv()
+
+def _extract_message_from_input(*input_args, **input_kwargs) -> str:
+    """Extract message from various input formats"""
+    
+    # Try different input field names
+    input_parts = []
+    for field in {input_fields_str}:
+        if input_kwargs.get(field):
+            input_parts.append(f"{{field}}: {{input_kwargs[field]}}")
+    
+    if not input_parts and input_args and isinstance(input_args[0], str):
+        input_parts.append(f"Input: {{input_args[0]}}")
+    
+    return "\\n".join(input_parts) if input_parts else "No input provided"
+
+def letta_run(*input_args, **input_kwargs):
+    """Main Letta agent function"""
+    try:
+        client = Letta(base_url="http://localhost:8283")
+        
+        # Create memory blocks
+        memory_blocks = [
+            CreateBlock(
+                label="human",
+                value="You are interacting with a user through RunAgent framework",
+            ),
+            CreateBlock(
+                label="persona", 
+                value="{agent_info['description']}. Be helpful and focused on: {agent_info['main_functionality']}",
+            ),
+        ]
+
+        # Create agent
+        agent = client.agents.create(
+            name=f"runagent-{agent_info['agent_name']}-{{os.getpid()}}",
+            memory_blocks=memory_blocks,
+            system="{agent_info['description']} Focus on: {agent_info['main_functionality']}",
+            model="openai/gpt-4o-mini",
+            embedding="openai/text-embedding-ada-002",
+            include_base_tools=True
+        )
+
+        # Extract message from input
+        message = _extract_message_from_input(*input_args, **input_kwargs)
+        
+        # Send message to agent
+        response = client.agents.messages.create(
+            agent_id=agent.id,
+            messages=[{{"role": "user", "content": message}}]
+        )
+
+        return response
+        
+    except Exception as e:
+        return f"Letta execution error: {{str(e)}}"
+
+def letta_run_stream(*input_args, **input_kwargs):
+    """Streaming Letta function"""
+    try:
+        client = Letta(base_url="http://localhost:8283")
+        
+        memory_blocks = [
+            CreateBlock(
+                label="human",
+                value="You are interacting with a user through RunAgent framework",
+            ),
+            CreateBlock(
+                label="persona",
+                value="{agent_info['description']}. Be helpful and focused on: {agent_info['main_functionality']}",
+            ),
+        ]
+
+        agent = client.agents.create(
+            name=f"runagent-{agent_info['agent_name']}-stream-{{os.getpid()}}",
+            memory_blocks=memory_blocks,
+            system="{agent_info['description']} Focus on: {agent_info['main_functionality']}",
+            model="openai/gpt-4o-mini", 
+            embedding="openai/text-embedding-ada-002",
+            include_base_tools=True
+        )
+
+        message = _extract_message_from_input(*input_args, **input_kwargs)
+        
+        stream = client.agents.messages.create_stream(
+            agent_id=agent.id,
+            messages=[{{"role": "user", "content": message}}],
+            stream_tokens=True,
+        )
+        
+        for chunk in stream:
+            yield chunk
+            
+    except Exception as e:
+        yield f"Letta streaming error: {{str(e)}}"
+'''
+    
+    with open(session_dir / "agent.py", "w") as f:
+        f.write(agent_code)
+    
+    # Generate requirements
+    with open(session_dir / "requirements.txt", "w") as f:
+        f.write("letta-client>=0.1.0\npython-dotenv>=1.0.0\n")
+    
+    # Generate config
+    config = {
+        "agent_name": agent_info['agent_name'],
+        "description": agent_info['description'],
+        "framework": "letta",
+        "template": "custom",
+        "version": "1.0.0",
+        "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "template_source": {
+            "repo_url": "https://github.com/runagent-dev/runagent.git",
+            "path": "generated/custom",
+            "author": "runagent-generator",
+            "version": "1.0.0"
+        },
+        "agent_architecture": {
+            "entrypoints": [
+                {
+                    "file": "agent.py",
+                    "module": "letta_run", 
+                    "tag": "main"
+                },
+                {
+                    "file": "agent.py",
+                    "module": "letta_run_stream",
+                    "tag": "main_stream"
+                }
+            ]
+        },
+        "input_fields": agent_info['input_fields'],
+        "input_types": agent_info['input_types'],
+        "input_descriptions": agent_info['input_descriptions'],
+        "env_vars": {
+            "OPENAI_API_KEY": "${OPENAI_API_KEY}",
+            "LETTA_SERVER_URL": "http://localhost:8283"
+        }
+    }
+    
+    with open(session_dir / "runagent.config.json", "w") as f:
+        json.dump(config, f, indent=2)
+
+def generate_llamaindex_files(agent_info: dict, session_dir: Path):
+    """Generate LlamaIndex agent files with proper input handling."""
+    
+    input_fields_str = json.dumps(agent_info['input_fields'])
+    
+    agent_code = f'''from llama_index.llms.openai import OpenAI
+from llama_index.core.agent.workflow import AgentStream
+from llama_index.core.agent.workflow import FunctionAgent
+
+# Define a simple tool based on agent functionality
+def process_request(query: str) -> str:
+    """Process user request based on agent functionality."""
+    return f"Processing: {{query}} for {agent_info['main_functionality']}"
+
+# Create an agent workflow
+agent = FunctionAgent(
+    tools=[process_request],
+    llm=OpenAI(model="gpt-4o-mini"),
+    system_prompt="{agent_info['description']} Focus on: {agent_info['main_functionality']}",
+)
+
+async def agent_run(*input_args, **input_kwargs):
+    """Main agent function"""
+    
+    # Extract input from various sources
+    input_parts = []
+    for field in {input_fields_str}:
+        if input_kwargs.get(field):
+            input_parts.append(f"{{field}}: {{input_kwargs[field]}}")
+    
+    if not input_parts and input_args:
+        input_parts.append(f"Input: {{str(input_args[0])}}")
+    
+    if not input_parts:
+        input_parts.append("No specific input provided")
+    
+    user_input = "\\n".join(input_parts)
+    
+    response = await agent.run(user_input)
+    return response
+
+async def agent_run_stream(*input_args, **input_kwargs):
+    """Streaming agent function"""
+    
+    input_parts = []
+    for field in {input_fields_str}:
+        if input_kwargs.get(field):
+            input_parts.append(f"{{field}}: {{input_kwargs[field]}}")
+    
+    if not input_parts and input_args:
+        input_parts.append(f"Input: {{str(input_args[0])}}")
+    
+    if not input_parts:
+        input_parts.append("No specific input provided")
+    
+    user_input = "\\n".join(input_parts)
+    
+    handler = agent.run(user_msg=user_input)
+    async for event in handler.stream_events():
+        if isinstance(event, AgentStream):
+            yield event
+        else:
+            yield str(event)
+'''
+    
+    with open(session_dir / "agent.py", "w") as f:
+        f.write(agent_code)
+    
+    # Generate requirements
+    with open(session_dir / "requirements.txt", "w") as f:
+        f.write("llama-index>=0.12.48\nllama-index-llms-openai>=0.3.0\n")
+    
+    # Generate config
+    config = {
+        "agent_name": agent_info['agent_name'],
+        "description": agent_info['description'],
+        "framework": "llamaindex",
+        "template": "custom",
+        "version": "1.0.0",
+        "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "template_source": {
+            "repo_url": "https://github.com/runagent-dev/runagent.git",
+            "path": "generated/custom",
+            "author": "runagent-generator",
+            "version": "1.0.0"
+        },
+        "agent_architecture": {
+            "entrypoints": [
+                {
+                    "file": "agent.py",
+                    "module": "agent_run",
+                    "tag": "main"
+                },
+                {
+                    "file": "agent.py",
+                    "module": "agent_run_stream",
+                    "tag": "main_stream"
+                }
+            ]
+        },
+        "input_fields": agent_info['input_fields'],
+        "input_types": agent_info['input_types'],
+        "input_descriptions": agent_info['input_descriptions'],
+        "env_vars": {
+            "OPENAI_API_KEY": "${OPENAI_API_KEY}"
+        }
+    }
+    
+    with open(session_dir / "runagent.config.json", "w") as f:
+        json.dump(config, f, indent=2)
+
+def generate_custom_framework_files(agent_info: dict, session_dir: Path):
+    """Generate custom framework files with proper input handling."""
+    
+    input_fields_str = json.dumps(agent_info['input_fields'])
+    
+    agent_code = f'''"""
+{agent_info['agent_name']} - {agent_info['description']}
+Generated by RunAgent Generator - Custom Framework
+"""
+
+def main(*input_args, **input_kwargs):
+    """Main entry point for custom agent"""
+    
+    # Extract input from various sources
+    input_parts = []
+    for field in {input_fields_str}:
+        if input_kwargs.get(field):
+            input_parts.append(f"{{field}}: {{input_kwargs[field]}}")
+    
+    if not input_parts and input_args:
+        input_parts.append(f"Input: {{str(input_args[0])}}")
+    
+    if not input_parts:
+        input_parts.append("Hello, how can I help you?")
+    
+    user_input = "\\n".join(input_parts)
+    
+    # Simple response for custom framework
+    response = f"""
+Hello! I'm {agent_info['agent_name']}.
+
+{agent_info['description']}
+
+You provided: {{user_input}}
+
+My main functionality is: {agent_info['main_functionality']}
+
+This is a custom framework implementation. You can modify this code to add your specific logic.
+    """
+    
+    return response.strip()
+
+def main_stream(*input_args, **input_kwargs):
+    """Streaming entry point for custom agent"""
+    
+    # Get the main response
+    response = main(*input_args, **input_kwargs)
+    
+    # Simulate streaming by yielding words
+    words = response.split()
+    for i, word in enumerate(words):
+        if i == 0:
+            yield word
+        else:
+            yield f" {{word}}"
+        
+        # Add small delay for demonstration
+        import time
+        time.sleep(0.01)
+'''
+    
+    with open(session_dir / "agent.py", "w") as f:
+        f.write(agent_code)
+    
+    # Generate minimal requirements
+    with open(session_dir / "requirements.txt", "w") as f:
+        f.write("# No additional requirements for custom framework\n")
+    
+    # Generate config
+    config = {
+        "agent_name": agent_info['agent_name'],
+        "description": agent_info['description'],
+        "framework": "custom",
+        "template": "custom",
+        "version": "1.0.0",
+        "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "template_source": {
+            "repo_url": "https://github.com/runagent-dev/runagent.git",
+            "path": "templates/custom/basic",
+            "author": "runagent-generator",
+            "version": "1.0.0"
+        },
+        "agent_architecture": {
+            "entrypoints": [
+                {
+                    "file": "agent.py",
+                    "module": "main",
+                    "tag": "main"
+                },
+                {
+                    "file": "agent.py",
+                    "module": "main_stream",
+                    "tag": "main_stream"
+                }
+            ]
+        },
+        "input_fields": agent_info['input_fields'],
+        "input_types": agent_info['input_types'],
+        "input_descriptions": agent_info['input_descriptions'],
+        "env_vars": {
+            "OPENAI_API_KEY": "${OPENAI_API_KEY}"
+        }
+    }
+    
+    with open(session_dir / "runagent.config.json", "w") as f:
+        json.dump(config, f, indent=2)
+
+def start_runagent_server(session_dir: str, session_id: str):
+    """Start runagent server and return connection info"""
+    
+    try:
+        print(f"🚀 Starting RunAgent server for session: {session_id}")
+        
+        # Install dependencies
+        print("📦 Installing agent dependencies...")
+        try:
+            result = subprocess.run(["pip", "install", "-r", "requirements.txt"], 
+                                  cwd=session_dir, capture_output=True, text=True, timeout=120)
+            if result.returncode == 0:
+                print("✅ Dependencies installed successfully")
+            else:
+                print(f"⚠️ Dependency installation: {result.stderr}")
+        except Exception as e:
+            print(f"⚠️ Dependency installation failed: {e}")
+        
+        # Set up environment
+        env = os.environ.copy()
+        env['RUNAGENT_DISABLE_DB'] = 'true'
+        env['RUNAGENT_LOG_LEVEL'] = 'INFO'
+        
+        # Start RunAgent server
+        cmd = ["runagent", "serve", "."]
+        
+        process = subprocess.Popen(
+            cmd,
+            cwd=session_dir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            universal_newlines=True,
+            env=env
+        )
+        
+        # Wait and extract info
+        detected_port = None
+        runagent_agent_id = None
+        
+        # Read output to get port and agent ID
+        for i in range(50):
+            try:
+                line = process.stdout.readline()
+                if line:
+                    print(f"RunAgent: {line.strip()}")
+                    
+                    if "Allocated address:" in line and "127.0.0.1:" in line:
+                        try:
+                            port_part = line.split("127.0.0.1:")[-1].strip()
+                            detected_port = int(port_part)
+                            print(f"🔌 Detected Port: {detected_port}")
+                        except:
+                            pass
+                    
+                    if "New agent created with ID:" in line:
+                        try:
+                            runagent_agent_id = line.split("ID:")[-1].strip()
+                            print(f"🆔 Detected RunAgent Agent ID: {runagent_agent_id}")
+                        except:
+                            pass
+                    
+                    if detected_port and runagent_agent_id:
+                        break
+                        
+                else:
+                    time.sleep(0.1)
+                    
+            except Exception as e:
+                print(f"Error reading line: {e}")
+                break
+        
+        # Default values if not detected
+        if not detected_port:
+            detected_port = 8450
+        if not runagent_agent_id:
+            runagent_agent_id = str(uuid.uuid4())
+        
+        # Wait for server to initialize
+        time.sleep(3)
+        
+        agent_url = f"http://localhost:8000/static/agent.html?agent={runagent_agent_id}"
+        
+        # Update session
+        session = sessions.get(session_id, {})
+        session["completion_time"] = time.time()
+        session["runagent_port"] = detected_port
+        session["agent_id"] = runagent_agent_id
+        
+        # Store running agent info
+        running_agents[runagent_agent_id] = {
+            "process": process,
+            "agent_id": runagent_agent_id,
+            "agent_url": agent_url,
+            "port": detected_port,
+            "runagent_url": f"http://localhost:{detected_port}",
+            "session_id": session_id,
+            "status": "active",
+            "agent_info": session.get("agent_info", {})
+        }
+        
+        print(f"🎉 RunAgent server started successfully!")
+        return runagent_agent_id, agent_url, detected_port
+        
+    except Exception as e:
+        print(f"❌ Error starting agent server: {e}")
+        import traceback
+        traceback.print_exc()
+        return None, None, None
+
+def generate_agent_files(agent_info: dict, session_id: str):
+    """Generate agent files based on framework and create test script"""
+    
+    try:
+        # Create session directory
+        session_dir = Path(f"generated_agents/{session_id}")
+        session_dir.mkdir(parents=True, exist_ok=True)
+        
+        print(f"Creating agent files in: {session_dir}")
+        print(f"Framework: {agent_info['framework']}")
+        
+        # Generate framework-specific files
+        framework = agent_info['framework'].lower()
+        
+        if framework == 'langgraph':
+            generate_langgraph_files(agent_info, session_dir)
+        elif framework == 'letta':
+            generate_letta_files(agent_info, session_dir)
+        elif framework == 'agno':
+            generate_agno_files(agent_info, session_dir)
+        elif framework == 'llamaindex':
+            generate_llamaindex_files(agent_info, session_dir)
+        else:
+            # Default to custom framework
+            generate_custom_framework_files(agent_info, session_dir)
+        
+        # Generate agent test script
+        print("Generating agent test script...")
+        script_success = generate_agent_test_script(agent_info, session_dir)
+        
+        if not script_success:
+            print("Warning: Test script generation had issues, but continuing...")
+        
+        # Generate .env file with basic setup
+        env_content = """# Environment variables for the agent
+OPENAI_API_KEY=${OPENAI_API_KEY}
+RUNAGENT_LOG_LEVEL=INFO
+RUNAGENT_DISABLE_DB=true
+"""
+        
+        with open(session_dir / ".env", "w") as f:
+            f.write(env_content)
+        
+        # Generate README
+        readme_content = f"""# {agent_info['agent_name']}
+
+{agent_info['description']}
+
+## Framework
+{agent_info['framework']}
+
+## Usage
+
+### Install dependencies
+```bash
+pip install -r requirements.txt
+```
+
+### Run with RunAgent
+```bash
+runagent serve .
+```
+
+### Test the agent
+```bash
+python3 agent_test.py <agent_id> localhost <port> "your test message"
+```
+
+## Input Fields
+{', '.join(agent_info['input_fields'])}
+
+## Entrypoints
+{', '.join(agent_info['entrypoint_tags'])}
+"""
+        
+        with open(session_dir / "README.md", "w") as f:
+            f.write(readme_content)
+        
+        print(f"Agent files generated successfully!")
+        print(f"Files created:")
+        for file_path in session_dir.glob("*"):
+            print(f"   - {file_path.name}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"Error generating agent files: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat_endpoint(request: ChatRequest):
+    """Main chat endpoint for agent generation."""
+    
+    session_id = request.session_id or str(uuid.uuid4())
+    message = request.message.strip()
+    
+    print(f"🔍 Received message: '{message}'")
+    print(f"🆔 Session ID: {session_id}")
+    
+    # Get or create session
+    if session_id not in sessions:
+        sessions[session_id] = {
+            "stage": "understanding",
+            "messages": [],
+            "agent_info": None,
+            "files_generated": False
+        }
+    
+    session = sessions[session_id]
+    session["messages"].append({"role": "user", "content": request.message})
+    
+    try:
+        # Stage 1: Understanding the request
+        if session["stage"] == "understanding":
+            print("🧠 Analyzing user request with GPT-5...")
+            agent_info = analyze_user_request(request.message)
+            session["agent_info"] = agent_info
+            session["stage"] = "planning"
+            
+            description = f"""I understand you want to create: **{agent_info['agent_name']}**
+
+**Framework:** {agent_info['framework']}
+**Description:** {agent_info['description']}
+**Main Functionality:** {agent_info['main_functionality']}
+**Input Fields:** {', '.join(agent_info['input_fields'])}
+**Expected Output:** {agent_info['expected_output_format']}
+
+Let me create a workflow diagram for this agent..."""
+
+            # Generate Mermaid diagram
+            mermaid_diagram = generate_mermaid_diagram(agent_info)
+            
+            # Include SDK configuration in response
+            sdk_config = {
+                "inputFields": [
+                    {
+                        "name": field,
+                        "type": agent_info['input_types'].get(field, "string"),
+                        "description": agent_info['input_descriptions'].get(field, f"Enter {field}"),
+                        "required": True,
+                        "placeholder": f"Enter {field}..."
+                    } for field in agent_info['input_fields']
+                ],
+                "entrypoints": [
+                    {
+                        "tag": tag,
+                        "description": f"Main {'streaming' if 'stream' in tag else 'synchronous'} endpoint",
+                        "streaming": "stream" in tag
+                    } for tag in agent_info['entrypoint_tags']
+                ],
+                "exampleInputs": agent_info['example_inputs']
+            }
+            
+            return ChatResponse(
+                response=description,
+                session_id=session_id,
+                stage="planning",
+                description=agent_info['description'],
+                mermaid_diagram=mermaid_diagram,
+                sdk_config=sdk_config
+            )
+        
+        # Stage 2: Planning
+        elif session["stage"] == "planning":
+            if any(phrase in message.lower() for phrase in ["go for it", "generate", "create it", "build it", "make it", "proceed", "continue", "yes", "start"]):
+                print(f"🚀 Starting agent generation for session {session_id}")
+                
+                # Generate agent files
+                success = generate_agent_files(session["agent_info"], session_id)
+                
+                if not success:
+                    raise Exception("Failed to generate agent files")
+                
+                session["files_generated"] = True
+                session["stage"] = "starting"
+                
+                # Start RunAgent server in background
+                session_dir_path = Path(f"generated_agents/{session_id}")
+                
+                def start_agent():
+                    try:
+                        agent_id, agent_url, port = start_runagent_server(str(session_dir_path), session_id)
+                        
+                        if agent_id and agent_url:
+                            session["agent_id"] = agent_id
+                            session["agent_url"] = agent_url
+                            session["runagent_port"] = port
+                            session["stage"] = "complete"
+                            
+                            running_agents[agent_id] = {
+                                "agent_info": session["agent_info"],
+                                "session_id": session_id,
+                                "status": "active",
+                                "port": port,
+                                "runagent_url": f"http://localhost:{port}"
+                            }
+                        else:
+                            session["stage"] = "error"
+                            session["error"] = "Failed to start RunAgent server"
+                    except Exception as e:
+                        session["stage"] = "error"
+                        session["error"] = str(e)
+                
+                threading.Thread(target=start_agent, daemon=True).start()
+                
+                return ChatResponse(
+                    response=f"""✅ Agent files generated successfully! Now starting the RunAgent server...
+
+🔄 Starting your **{session["agent_info"]["agent_name"]}** agent server...
+
+This involves:
+1. Installing {session["agent_info"]["framework"]} dependencies
+2. Starting RunAgent server on available port
+3. Initializing your agent with custom TypeScript SDK integration
+
+⏳ Please wait 30-90 seconds, then **send any message** to check if it's ready.""",
+                    session_id=session_id,
+                    stage="starting"
+                )
+            else:
+                # Handle modifications
+                mermaid_diagram = generate_mermaid_diagram(session["agent_info"])
+                return ChatResponse(
+                    response="I can help you modify the agent. What would you like to change? Or say 'go for it' or 'generate' to proceed with the current design.",
+                    session_id=session_id,
+                    stage="planning",
+                    description=session["agent_info"]["description"],
+                    mermaid_diagram=mermaid_diagram
+                )
+        
+        # Stage 3: Check agent status
+        elif session["stage"] == "starting":
+            if session.get("agent_id") and session.get("agent_url"):
+                session["stage"] = "complete"
+                agent_id = session["agent_id"]
+                agent_url = session["agent_url"]
+                runagent_port = session.get("runagent_port")
+                
+                return ChatResponse(
+                    response=f"""🎉 Your **{session["agent_info"]["agent_name"]}** is now ready!
+
+**Agent ID:** `{agent_id}`
+
+**🚀 Click here to use your agent:**
+{agent_url}
+
+**RunAgent Server:** `http://localhost:{runagent_port}`
+
+Your {session["agent_info"]["framework"]} agent is running with:
+- Dynamic input fields based on your requirements
+- Custom TypeScript SDK integration
+- Both synchronous and streaming endpoints
+
+The agent interface will automatically configure inputs based on the generated SDK configuration!""",
+                    session_id=session_id,
+                    stage="complete",
+                    agent_id=agent_id,
+                    agent_url=agent_url
+                )
+            elif session.get("stage") == "error":
+                error_msg = session.get("error", "Unknown error occurred")
+                return ChatResponse(
+                    response=f"❌ Error starting agent: {error_msg}\n\nPlease try again or check the server logs.",
+                    session_id=session_id,
+                    stage="error"
+                )
+            else:
+                return ChatResponse(
+                    response="""⏳ Still starting your agent server... 
+
+The process includes:
+- Installing dependencies
+- Generating TypeScript SDK integration
+- Initializing the RunAgent framework
+- Starting the server and verifying connectivity
+
+Please wait a bit longer and send another message to check status.""",
+                    session_id=session_id,
+                    stage="starting"
+                )
+        
+        # Agent is complete
+        else:
+            if session["stage"] == "complete":
+                agent_id = session.get("agent_id")
+                agent_url = session.get("agent_url") 
+                runagent_port = session.get("runagent_port")
+                
+                return ChatResponse(
+                    response=f"""🎉 Your **{session["agent_info"]["agent_name"]}** is ready!
+
+**Agent ID:** `{agent_id}`
+
+**🚀 Click here to use your agent:**
+{agent_url}
+
+**RunAgent Server:** `http://localhost:{runagent_port}` 
+
+Your {session["agent_info"]["framework"]} agent is running with dynamic inputs and TypeScript SDK integration!""",
+                    session_id=session_id,
+                    stage="complete",
+                    agent_id=agent_id,
+                    agent_url=agent_url
+                )
+            else:
+                return ChatResponse(
+                    response=f"Your agent status: {session.get('stage', 'unknown')}. How can I help you?",
+                    session_id=session_id,
+                    stage=session.get("stage", "understanding")
+                )
+    
+    except Exception as e:
+        print(f"❌ Error in chat endpoint: {e}")
+        import traceback
+        traceback.print_exc()
+        
+        return ChatResponse(
+            response=f"Sorry, I encountered an error: {str(e)}\n\nPlease check the server logs and try again.",
+            session_id=session_id,
+            stage="error"
+        )
+
+@app.get("/agent/{agent_id}")
+async def get_agent_info(agent_id: str):
+    """Get comprehensive agent information"""
+    try:
+        print(f"Looking for agent ID: {agent_id}")
+        
+        # Find agent data
+        agent_data = None
+        session_id = None
+        
+        if agent_id in running_agents:
+            agent_data = running_agents[agent_id]
+            session_id = agent_data.get("session_id")
+        else:
+            # Check sessions
+            for sid, session in sessions.items():
+                if session.get("agent_id") == agent_id:
+                    session_id = sid
+                    agent_info = session.get("agent_info", {})
+                    port = session.get("runagent_port", 8450)
+                    agent_data = {
+                        "agent_info": agent_info,
+                        "port": port
+                    }
+                    break
+        
+        if not agent_data:
+            raise HTTPException(status_code=404, detail=f"Agent {agent_id} not found")
+        
+        agent_info = agent_data.get("agent_info", {})
+        port = agent_data.get("port", 8450)
+        
+        # Check if test script exists
+        script_available = False
+        script_url = None
+        if session_id:
+            script_file = Path(f"generated_agents/{session_id}/agent_test.py")
+            if script_file.exists():
+                script_available = True
+                script_url = f"http://localhost:8000/agent/{agent_id}/sdk"
+        
+        return {
+            "agent_info": {
+                "agent_name": agent_info.get("agent_name", "Unknown Agent"),
+                "description": agent_info.get("description", "AI Agent"),
+                "framework": agent_info.get("framework", "custom"),
+                "input_fields": agent_info.get("input_fields", ["query"]),
+                "input_types": agent_info.get("input_types", {"query": "string"}),
+                "input_descriptions": agent_info.get("input_descriptions", {"query": "User input"}),
+                "main_functionality": agent_info.get("main_functionality", "General assistance"),
+                "expected_output_format": agent_info.get("expected_output_format", "String response"),
+                "example_inputs": agent_info.get("example_inputs", [{"query": "Hello"}]),
+                "entrypoint_tags": agent_info.get("entrypoint_tags", ["main", "main_stream"]),
+                "port": port,
+                "runagent_url": f"http://localhost:{port}",
+                "runagent_agent_id": agent_id,
+                "status": "ready",
+                "script_available": script_available,
+                "script_url": script_url,
+                "session_id": session_id
+            }
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"Error getting agent info: {e}")
+        raise HTTPException(status_code=500, detail=f"Server error: {str(e)}")
+
+@app.get("/agent/{agent_id}/sdk")
+async def serve_agent_test_script(agent_id: str):
+    """Serve the generated agent test script"""
+    try:
+        # Find the session directory
+        session_id = None
+        for sid, session in sessions.items():
+            if session.get("agent_id") == agent_id:
+                session_id = sid
+                break
+        
+        if not session_id:
+            raise HTTPException(status_code=404, detail="Agent session not found")
+        
+        test_file = Path(f"generated_agents/{session_id}/agent_test.py")
+        if not test_file.exists():
+            raise HTTPException(status_code=404, detail="Test script not found")
+        
+        # Read and return the test script
+        with open(test_file, "r") as f:
+            script_content = f.read()
+        
+        return Response(
+            content=script_content,
+            media_type="text/plain",
+            headers={
+                "Cache-Control": "no-cache",
+                "Content-Disposition": f"attachment; filename=agent_test_{agent_id}.py"
+            }
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error serving test script: {str(e)}")
+
+
+@app.get("/agent/{agent_id}/sdk-config")
+async def get_agent_sdk_config(agent_id: str):
+    """Get the generated SDK configuration for the agent"""
+    try:
+        # Find the session directory
+        session_id = None
+        for sid, session in sessions.items():
+            if session.get("agent_id") == agent_id:
+                session_id = sid
+                break
+        
+        if not session_id:
+            raise HTTPException(status_code=404, detail="Agent session not found")
+        
+        sdk_file = Path(f"generated_agents/{session_id}/sdk_test.js")
+        if not sdk_file.exists():
+            raise HTTPException(status_code=404, detail="SDK configuration not found")
+        
+        # Read and return the SDK file content
+        with open(sdk_file, "r") as f:
+            sdk_content = f.read()
+        
+        return {
+            "agent_id": agent_id,
+            "sdk_content": sdk_content,
+            "file_path": str(sdk_file)
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error reading SDK config: {str(e)}")
+
+@app.get("/debug/test-agent/{agent_id}")
+async def debug_test_agent(agent_id: str, test_input: str = "Hello, how can you help me?"):
+    """Debug endpoint to test agent functionality directly"""
+    try:
+        import requests
+        
+        # Find agent info
+        agent_data = None
+        if agent_id in running_agents:
+            agent_data = running_agents[agent_id]
+        else:
+            # Check sessions
+            for session_id, session in sessions.items():
+                if session.get("agent_id") == agent_id:
+                    port = session.get("runagent_port", 8450)
+                    agent_info = session.get("agent_info", {})
+                    agent_data = {
+                        "port": port,
+                        "agent_info": agent_info
+                    }
+                    break
+        
+        if not agent_data:
+            return {"error": f"Agent {agent_id} not found"}
+        
+        port = agent_data.get("port", 8450)
+        agent_info = agent_data.get("agent_info", {})
+        base_url = f"http://localhost:{port}"
+        
+        # Get first input field name
+        input_fields = agent_info.get("input_fields", ["query"])
+        first_field = input_fields[0] if input_fields else "query"
+        
+        test_data = {first_field: test_input}
+        
+        # Test different endpoints
+        endpoints_to_test = [
+            "/agents/main/run",
+            "/agents/main/invoke", 
+            "/run",
+            "/invoke"
+        ]
+        
+        results = {}
+        
+        for endpoint in endpoints_to_test:
+            try:
+                response = requests.post(
+                    f"{base_url}{endpoint}",
+                    json=test_data,
+                    timeout=10
+                )
+                
+                results[endpoint] = {
+                    "status_code": response.status_code,
+                    "success": response.status_code == 200,
+                    "content": response.text[:500] if response.text else "",
+                    "headers": dict(response.headers)
+                }
+                
+            except Exception as e:
+                results[endpoint] = {
+                    "status_code": "error",
+                    "success": False,
+                    "error": str(e)
+                }
+        
+        return {
+            "agent_id": agent_id,
+            "port": port,
+            "base_url": base_url,
+            "test_input": test_data,
+            "results": results,
+            "agent_info": {
+                "name": agent_info.get("agent_name", "Unknown"),
+                "framework": agent_info.get("framework", "unknown"),
+                "input_fields": input_fields
+            }
+        }
+        
+    except Exception as e:
+        return {"error": f"Debug test failed: {str(e)}"}
+
+from fastapi.responses import StreamingResponse
+import asyncio
+
+@app.get("/agent/{agent_id}/run-test-stream")
+async def run_streaming_test_live(
+    agent_id: str, 
+    test_message: str = "Hello, streaming test",
+    input_data: str = None,
+    entrypoint_tag: str = None
+):
+    """Live streaming test that sends output as it's generated"""
+    try:
+        # Find the session directory
+        session_id = None
+        for sid, session in sessions.items():
+            if session.get("agent_id") == agent_id:
+                session_id = sid
+                break
+        
+        if not session_id:
+            raise HTTPException(status_code=404, detail="Agent session not found")
+        
+        session_dir = Path(f"generated_agents/{session_id}")
+        session = sessions[session_id]
+        agent_info = session.get("agent_info", {})
+        port = session.get("runagent_port", 8450)
+        
+        # Parse input data if provided
+        dynamic_inputs = {}
+        if input_data:
+            try:
+                dynamic_inputs = json.loads(input_data)
+            except json.JSONDecodeError:
+                pass
+        
+        # Create the enhanced test script (same as before)
+        temp_script_content = f'''import sys
+import json
+import time
+import os
+
+# Use line buffering for real-time output
+sys.stdout.reconfigure(line_buffering=True)
+sys.stderr.reconfigure(line_buffering=True)
+
+sys.path.insert(0, "{str(session_dir)}")
+
+def enhanced_streaming_test():
+    agent_id = "{agent_id}"
+    host = "localhost"
+    port = {port}
+    test_message = "{test_message}"
+    
+    print(f"🧪 Starting Streaming Test")
+    print(f"🔌 Connection: {{host}}:{{port}}")
+    print(f"📝 Test Message: {{test_message}}")
+    print("=" * 50)
+    
+    # Dynamic inputs
+    dynamic_inputs = {json.dumps(dynamic_inputs)}
+    
+    from runagent import RunAgentClient
+    
+    # Find streaming entrypoint
+    all_entrypoints = {agent_info['entrypoint_tags']}
+    streaming_tags = [tag for tag in all_entrypoints if "stream" in tag.lower()]
+    
+    if not streaming_tags:
+        streaming_tags = all_entrypoints
+    
+    target_tag = "{entrypoint_tag}" if "{entrypoint_tag}" else streaming_tags[0] if streaming_tags else "main_stream"
+    
+    print(f"🎯 Using entrypoint: {{target_tag}}")
+    print("-" * 40)
+    
+    # Prepare input data
+    if dynamic_inputs:
+        input_data = dynamic_inputs.copy()
+    else:
+        primary_field = "{agent_info['input_fields'][0] if agent_info['input_fields'] else 'query'}"
+        input_data = {{primary_field: test_message}}
+    
+    try:
+        ra = RunAgentClient(
+            agent_id=agent_id,
+            entrypoint_tag=target_tag,
+            local=True
+        )
+        
+        print(f"✅ Client created successfully")
+        print(f"📡 Starting stream...")
+        print("-" * 40)
+        
+        chunk_count = 0
+        for chunk in ra.run(**input_data):
+            chunk_count += 1
+            
+            # Handle different chunk types
+            if isinstance(chunk, dict):
+                content = chunk.get('content', '')
+                if content:
+                    print(content, end="", flush=True)
+                else:
+                    print(str(chunk), flush=True)
+            else:
+                print(chunk, end="", flush=True)
+            
+            if chunk_count > 200:  # Prevent infinite loops
+                print("\\n... [truncated after 200 chunks]")
+                break
+        
+        print(f"\\n-" * 40)
+        print(f"🎉 Stream completed with {{chunk_count}} chunks")
+        
+    except Exception as e:
+        print(f"❌ Streaming error: {{str(e)}}")
+
+if __name__ == "__main__":
+    enhanced_streaming_test()
+'''
+        
+        # Write the streaming test script
+        temp_script = session_dir / "streaming_test.py"
+        with open(temp_script, "w") as f:
+            f.write(temp_script_content)
+        
+        async def generate_stream():
+            """Generator function for streaming output"""
+            try:
+                # Prepare environment
+                env = os.environ.copy()
+                env['PYTHONPATH'] = str(Path.cwd())
+                env['PYTHONUNBUFFERED'] = '1'
+                
+                # Start the process
+                process = subprocess.Popen(
+                    ["python3", "streaming_test.py"],
+                    cwd=session_dir,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    text=True,
+                    bufsize=1,
+                    universal_newlines=True,
+                    env=env
+                )
+                
+                # Read output line by line as it's generated
+                while True:
+                    output = process.stdout.readline()
+                    if output == '' and process.poll() is not None:
+                        break
+                    if output:
+                        # Send as Server-Sent Event format
+                        yield f"data: {json.dumps({'type': 'output', 'content': output.rstrip()})}\n\n"
+                        await asyncio.sleep(0.01)  # Small delay for better streaming effect
+                
+                # Send completion event
+                return_code = process.poll()
+                yield f"data: {json.dumps({'type': 'complete', 'return_code': return_code})}\n\n"
+                
+            except Exception as e:
+                yield f"data: {json.dumps({'type': 'error', 'content': str(e)})}\n\n"
+            finally:
+                # Clean up temp script
+                if temp_script.exists():
+                    temp_script.unlink()
+        
+        return StreamingResponse(
+            generate_stream(),
+            media_type="text/plain",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Content-Type": "text/event-stream",
+            }
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Streaming test failed: {str(e)}")
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "active_sessions": len(sessions)}
+
+@app.get("/debug/clear-sessions")
+async def clear_sessions():
+    """Clear all sessions and running agents for debugging."""
+    global sessions, running_agents
+    
+    # Stop any running processes
+    for agent_id, agent_data in running_agents.items():
+        if "process" in agent_data and agent_data["process"]:
+            try:
+                agent_data["process"].terminate()
+                print(f"🛑 Terminated process for agent {agent_id}")
+            except:
+                pass
+    
+    sessions.clear()
+    running_agents.clear()
+    
+    return {"message": "All sessions and agents cleared", "status": "success"}
+
+@app.get("/agent/{agent_id}/run-test")
+async def run_python_sdk_test(
+    agent_id: str, 
+    test_message: str = "Hello, how can you help me?",
+    input_data: str = None,
+    streaming: bool = False,
+    entrypoint_tag: str = None
+):
+    """Run the Python SDK test with dynamic input data and streaming support"""
+    try:
+        # Find the session directory
+        session_id = None
+        for sid, session in sessions.items():
+            if session.get("agent_id") == agent_id:
+                session_id = sid
+                break
+        
+        if not session_id:
+            raise HTTPException(status_code=404, detail="Agent session not found")
+        
+        session_dir = Path(f"generated_agents/{session_id}")
+        python_file = session_dir / "agent_test.py"
+        
+        if not python_file.exists():
+            raise HTTPException(status_code=404, detail="Python SDK file not found")
+        
+        # Get agent info
+        session = sessions[session_id]
+        agent_info = session.get("agent_info", {})
+        port = session.get("runagent_port", 8450)
+        
+        # Parse input data if provided
+        dynamic_inputs = {}
+        if input_data:
+            try:
+                dynamic_inputs = json.loads(input_data)
+                print(f"📋 Using dynamic inputs: {dynamic_inputs}")
+            except json.JSONDecodeError:
+                print(f"⚠️ Failed to parse input_data, using test_message only")
+        
+        # Prepare environment
+        env = os.environ.copy()
+        env['PYTHONPATH'] = str(Path.cwd())
+        
+        # Create a temporary script that handles dynamic inputs and proper content extraction
+        temp_script_content = f'''import sys
+import json
+import os
+sys.path.insert(0, os.path.dirname(__file__))
+
+def enhanced_main():
+    if len(sys.argv) < 5:
+        print("Usage: python3 enhanced_test.py <agent_id> <host> <port> <test_message> [streaming] [entrypoint]")
+        sys.exit(1)
+    
+    agent_id = sys.argv[1]
+    host = sys.argv[2] 
+    port = int(sys.argv[3])
+    test_message = sys.argv[4]
+    streaming_mode = sys.argv[5] if len(sys.argv) > 5 else "false"
+    target_entrypoint = sys.argv[6] if len(sys.argv) > 6 else None
+    
+    print(f"🧪 Enhanced Testing Agent: {{agent_id}}")
+    print(f"🔌 Connection: {{host}}:{{port}}")
+    print(f"📝 Test Message: {{test_message}}")
+    print(f"🌊 Streaming Mode: {{streaming_mode}}")
+    if target_entrypoint:
+        print(f"🎯 Target Entrypoint: {{target_entrypoint}}")
+    
+    # Use dynamic inputs if available
+    dynamic_inputs = {json.dumps(dynamic_inputs)}
+    
+    from runagent import RunAgentClient
+    import time
+    
+    # Determine entrypoints to test
+    all_entrypoints = {agent_info['entrypoint_tags']}
+    
+    if target_entrypoint:
+        entrypoints_to_test = [target_entrypoint]
+    elif streaming_mode.lower() == "true":
+        entrypoints_to_test = [tag for tag in all_entrypoints if "stream" in tag.lower()]
+        if not entrypoints_to_test:
+            entrypoints_to_test = all_entrypoints
+    else:
+        # For non-streaming, prefer non-stream entrypoints
+        entrypoints_to_test = [tag for tag in all_entrypoints if "stream" not in tag.lower()]
+        if not entrypoints_to_test:
+            entrypoints_to_test = all_entrypoints
+    
+    print(f"🎯 Testing entrypoints: {{entrypoints_to_test}}")
+    print("=" * 60)
+    
+    # Prepare input data
+    if dynamic_inputs:
+        input_data = dynamic_inputs.copy()
+        print(f"📋 Using dynamic inputs: {{json.dumps(input_data, indent=2)}}")
+    else:
+        # Fallback to test message mapping
+        primary_field = "{agent_info['input_fields'][0] if agent_info['input_fields'] else 'query'}"
+        input_data = {{primary_field: test_message}}
+        print(f"📋 Using fallback input: {{json.dumps(input_data, indent=2)}}")
+    
+    # Test each entrypoint
+    for i, tag in enumerate(entrypoints_to_test, 1):
+        try:
+            print(f"\\n🎯 Attempt {{i}}/{{len(entrypoints_to_test)}}: Testing '{{tag}}'")
+            start_time = time.time()
+            
+            ra = RunAgentClient(
+                agent_id=agent_id,
+                entrypoint_tag=tag,
+                local=True
+            )
+            
+            print(f"✅ RunAgentClient created successfully")
+            
+            if "stream" in tag.lower() or streaming_mode.lower() == "true":
+                print("📡 Testing streaming mode:")
+                print("-" * 40)
+                chunk_count = 0
+                accumulated_content = ""
+                
+                for chunk in ra.run(**input_data):
+                    chunk_count += 1
+                    
+                    # Extract content from chunk if it's a dict
+                    if isinstance(chunk, dict):
+                        content = chunk.get('content', '')
+                        if content:
+                            print(content, end="", flush=True)
+                            accumulated_content += content
+                    else:
+                        print(chunk, end="", flush=True)
+                        accumulated_content += str(chunk)
+                    
+                    if chunk_count > 200:  # Prevent infinite loops
+                        print("\\n... [truncated after 200 chunks]")
+                        break
+                
+                print(f"\\n-" * 40)
+                print(f"📊 Received {{chunk_count}} chunks")
+                print(f"📏 Total content length: {{len(accumulated_content)}} characters")
+                
+            else:
+                print("🔄 Testing synchronous mode:")
+                result = ra.run(**input_data)
+                
+                print(f"📤 Result Type: {{type(result)}}")
+                
+                # Handle different result types
+                if isinstance(result, dict):
+                    if 'content' in result:
+                        content = result['content']
+                        if hasattr(content, '__iter__') and not isinstance(content, str):
+                            # If content is a generator or iterator, consume it
+                            try:
+                                if hasattr(content, '__next__'):
+                                    print("🔄 Consuming generator/iterator result:")
+                                    consumed_content = ""
+                                    chunk_count = 0
+                                    for chunk in content:
+                                        if isinstance(chunk, dict) and 'content' in chunk:
+                                            consumed_content += chunk['content']
+                                        else:
+                                            consumed_content += str(chunk)
+                                        chunk_count += 1
+                                        if chunk_count > 100:
+                                            consumed_content += "... [truncated]"
+                                            break
+                                    print(f"📤 Consumed Content:\\n{{consumed_content}}")
+                                else:
+                                    print(f"📤 Content: {{content}}")
+                            except Exception as e:
+                                print(f"⚠️ Error consuming iterator: {{e}}")
+                                print(f"📤 Raw Content: {{content}}")
+                        else:
+                            print(f"📤 Content:\\n{{content}}")
+                    else:
+                        print(f"📤 Full Result:")
+                        result_str = json.dumps(result, indent=2, default=str)
+                        print(result_str[:2000] + "..." if len(result_str) > 2000 else result_str)
+                else:
+                    result_str = str(result)
+                    print(f"📤 Result Content:")
+                    print(result_str[:2000] + "..." if len(result_str) > 2000 else result_str)
+            
+            elapsed = time.time() - start_time
+            print(f"\\n⏱️  Execution Time: {{elapsed:.2f}} seconds")
+            print(f"🎉 SUCCESS! Agent responded via entrypoint '{{tag}}'")
+            sys.exit(0)
+            
+        except Exception as e:
+            print(f"❌ Failed with entrypoint '{{tag}}': {{str(e)}}")
+            if i < len(entrypoints_to_test):
+                print("🔄 Trying next entrypoint...")
+            continue
+    
+    print(f"\\n💥 All {{len(entrypoints_to_test)}} entrypoints failed!")
+    sys.exit(1)
+
+if __name__ == "__main__":
+    enhanced_main()
+'''
+        
+        # Write the enhanced test script
+        temp_script = session_dir / "enhanced_test.py"
+        with open(temp_script, "w") as f:
+            f.write(temp_script_content)
+        
+        # Prepare command arguments
+        cmd_args = [
+            "python3", "enhanced_test.py", 
+            agent_id, "localhost", str(port), test_message
+        ]
+        
+        if streaming:
+            cmd_args.append("true")
+            if entrypoint_tag:
+                cmd_args.append(entrypoint_tag)
+        
+        print(f"🚀 Running command: {' '.join(cmd_args)}")
+        
+        # Run the enhanced test
+        test_result = subprocess.run(
+            cmd_args,
+            cwd=session_dir,
+            capture_output=True,
+            text=True,
+            timeout=120,  # Increased timeout for streaming
+            env=env
+        )
+        
+        # Clean up temp script
+        if temp_script.exists():
+            temp_script.unlink()
+        
+        success = test_result.returncode == 0
+        
+        return {
+            "success": success,
+            "test_stdout": test_result.stdout,
+            "test_stderr": test_result.stderr,
+            "agent_info": {
+                "name": agent_info.get("agent_name", "Unknown"),
+                "framework": agent_info.get("framework", "unknown"),
+                "port": port,
+                "input_fields": agent_info.get("input_fields", []),
+                "entrypoint_tags": agent_info.get("entrypoint_tags", [])
+            },
+            "sdk_type": "python",
+            "streaming_mode": streaming,
+            "dynamic_inputs_used": bool(dynamic_inputs),
+            "inputs_received": dynamic_inputs if dynamic_inputs else {"test_message": test_message}
+        }
+        
+    except subprocess.TimeoutExpired:
+        return {
+            "success": False,
+            "error": "Test timeout (120s exceeded)",
+            "sdk_type": "python",
+            "streaming_mode": streaming
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Test failed: {str(e)}",
+            "sdk_type": "python",
+            "streaming_mode": streaming
+        }
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    # Create directories
+    os.makedirs("generated_agents", exist_ok=True)
+    os.makedirs("static", exist_ok=True)
+    
+    uvicorn.run(app, host="0.0.0.0", port=8000)
\ No newline at end of file
diff --git a/examples/Vibe_Agent_Builder_gpt_5/static/agent.html b/examples/Vibe_Agent_Builder_gpt_5/static/agent.html
new file mode 100644
index 0000000..7eaa442
--- /dev/null
+++ b/examples/Vibe_Agent_Builder_gpt_5/static/agent.html
@@ -0,0 +1,964 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Agent Interface</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Inter', sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+            line-height: 1.6;
+        }
+
+        .container {
+            max-width: 1400px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 24px;
+            box-shadow: 0 25px 50px rgba(0,0,0,0.15);
+            overflow: hidden;
+        }
+
+        .header {
+            background: linear-gradient(135deg, #1e293b 0%, #334155 100%);
+            color: white;
+            padding: 30px 40px;
+            position: relative;
+        }
+
+        .header-content {
+            display: flex;
+            align-items: center;
+            gap: 16px;
+            margin-bottom: 20px;
+        }
+
+        .header-icon {
+            width: 48px;
+            height: 48px;
+            border-radius: 12px;
+            box-shadow: 0 4px 12px rgba(0,0,0,0.2);
+        }
+
+        .header-text h1 {
+            font-size: 2.2rem;
+            margin-bottom: 4px;
+            font-weight: 600;
+            letter-spacing: -0.02em;
+            text-transform: capitalize;
+        }
+
+        .header-text p {
+            font-size: 1rem;
+            opacity: 0.85;
+            font-weight: 400;
+            margin: 0;
+        }
+
+        .agent-info {
+            background: rgba(255,255,255,0.08);
+            padding: 20px 24px;
+            border-radius: 16px;
+            margin-top: 20px;
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+            gap: 16px;
+            backdrop-filter: blur(10px);
+            border: 1px solid rgba(255,255,255,0.1);
+        }
+
+        .info-item {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 4px 0;
+        }
+
+        .info-item strong {
+            font-weight: 500;
+            opacity: 0.9;
+            font-size: 0.9rem;
+        }
+
+        .info-item span {
+            font-weight: 600;
+            font-family: 'SF Mono', 'Monaco', 'Consolas', monospace;
+            font-size: 0.85rem;
+        }
+
+        .status-badge {
+            background: linear-gradient(135deg, #059669, #10b981);
+            color: white;
+            padding: 8px 16px;
+            border-radius: 20px;
+            font-size: 0.8rem;
+            font-weight: 500;
+            grid-column: span 2;
+            justify-self: center;
+            text-align: center;
+            box-shadow: 0 4px 12px rgba(5, 150, 105, 0.3);
+        }
+
+        .main-content {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 24px;
+            padding: 24px;
+            min-height: 70vh;
+        }
+
+        .panel {
+            background: #f8fafc;
+            border-radius: 20px;
+            padding: 24px;
+            border: 1px solid #e2e8f0;
+            position: relative;
+        }
+
+        .panel::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            height: 4px;
+            background: linear-gradient(90deg, #667eea, #764ba2);
+            border-radius: 20px 20px 0 0;
+        }
+
+        .panel h3 {
+            color: #1e293b;
+            margin-bottom: 20px;
+            font-size: 1.25rem;
+            font-weight: 600;
+            letter-spacing: -0.01em;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .form-group {
+            margin-bottom: 18px;
+        }
+
+        .form-group label {
+            display: block;
+            margin-bottom: 6px;
+            font-weight: 500;
+            color: #374151;
+            font-size: 0.95rem;
+            text-transform: capitalize;
+        }
+
+        .form-control {
+            width: 100%;
+            padding: 12px 16px;
+            border: 2px solid #e5e7eb;
+            border-radius: 12px;
+            font-size: 14px;
+            background: white;
+            transition: all 0.2s ease;
+            font-family: inherit;
+        }
+
+        .form-control:focus {
+            outline: none;
+            border-color: #667eea;
+            box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+            transform: translateY(-1px);
+        }
+
+        .form-control.textarea {
+            min-height: 70px;
+            resize: vertical;
+            font-family: inherit;
+        }
+
+        .btn {
+            padding: 12px 24px;
+            border: none;
+            border-radius: 12px;
+            font-size: 14px;
+            cursor: pointer;
+            margin: 6px 8px 6px 0;
+            transition: all 0.2s ease;
+            font-weight: 500;
+            position: relative;
+            overflow: hidden;
+        }
+
+        .btn::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: -100%;
+            width: 100%;
+            height: 100%;
+            background: linear-gradient(90deg, transparent, rgba(255,255,255,0.2), transparent);
+            transition: left 0.5s;
+        }
+
+        .btn:hover::before {
+            left: 100%;
+        }
+
+        .btn-primary { 
+            background: linear-gradient(135deg, #3b82f6, #1d4ed8); 
+            color: white;
+            box-shadow: 0 4px 12px rgba(59, 130, 246, 0.3);
+        }
+        .btn-success { 
+            background: linear-gradient(135deg, #10b981, #059669); 
+            color: white;
+            box-shadow: 0 4px 12px rgba(16, 185, 129, 0.3);
+        }
+        .btn-warning { 
+            background: linear-gradient(135deg, #f59e0b, #d97706); 
+            color: white;
+            box-shadow: 0 4px 12px rgba(245, 158, 11, 0.3);
+        }
+        .btn-info { 
+            background: linear-gradient(135deg, #06b6d4, #0891b2); 
+            color: white;
+            box-shadow: 0 4px 12px rgba(6, 182, 212, 0.3);
+        }
+        .btn-secondary { 
+            background: linear-gradient(135deg, #6b7280, #4b5563); 
+            color: white;
+            box-shadow: 0 4px 12px rgba(107, 114, 128, 0.3);
+        }
+
+        .btn:hover:not(:disabled) {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 25px rgba(0,0,0,0.15);
+        }
+
+        .btn:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        .output {
+            background: #ffffff;
+            border: 2px solid #e5e7eb;
+            border-radius: 16px;
+            padding: 20px;
+            font-family: 'SF Mono', 'Monaco', 'Consolas', monospace;
+            font-size: 13px;
+            line-height: 1.5;
+            white-space: pre-wrap;
+            color: #374151;
+            max-height: 400px;
+            overflow-y: auto;
+            margin-top: 12px;
+            box-shadow: inset 0 2px 8px rgba(0,0,0,0.06);
+        }
+
+        .output.error { 
+            border-color: #f87171; 
+            background: #fef2f2; 
+            color: #991b1b; 
+        }
+        .output.success { 
+            border-color: #34d399; 
+            background: #ecfdf5; 
+            color: #065f46; 
+        }
+        .output.info { 
+            border-color: #60a5fa; 
+            background: #eff6ff; 
+            color: #1e40af; 
+        }
+
+        .loading-spinner {
+            display: inline-block;
+            width: 16px;
+            height: 16px;
+            border: 2px solid #e5e7eb;
+            border-top: 2px solid #667eea;
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            margin-right: 8px;
+        }
+
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+
+        .tabs {
+            display: flex;
+            gap: 4px;
+            margin-bottom: 20px;
+            background: #e5e7eb;
+            padding: 4px;
+            border-radius: 12px;
+        }
+
+        .tab {
+            padding: 10px 20px;
+            border-radius: 8px;
+            background: transparent;
+            cursor: pointer;
+            font-size: 14px;
+            font-weight: 500;
+            transition: all 0.2s ease;
+            color: #6b7280;
+            flex: 1;
+            text-align: center;
+        }
+
+        .tab.active {
+            background: white;
+            color: #1e293b;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+        }
+
+        .tab-content {
+            display: none;
+        }
+
+        .tab-content.active {
+            display: block;
+        }
+
+        .streaming-indicator {
+            display: inline-block;
+            width: 10px;
+            height: 10px;
+            border-radius: 50%;
+            background: linear-gradient(135deg, #10b981, #059669);
+            animation: pulse 1.5s infinite;
+            margin-right: 8px;
+            box-shadow: 0 0 8px rgba(16, 185, 129, 0.5);
+        }
+
+        @keyframes pulse {
+            0%, 100% { opacity: 1; transform: scale(1); }
+            50% { opacity: 0.7; transform: scale(1.1); }
+        }
+
+        /* Beautiful scrollbar */
+        .output::-webkit-scrollbar {
+            width: 8px;
+        }
+
+        .output::-webkit-scrollbar-track {
+            background: #f1f5f9;
+            border-radius: 4px;
+        }
+
+        .output::-webkit-scrollbar-thumb {
+            background: linear-gradient(135deg, #cbd5e1, #94a3b8);
+            border-radius: 4px;
+        }
+
+        .output::-webkit-scrollbar-thumb:hover {
+            background: linear-gradient(135deg, #94a3b8, #64748b);
+        }
+
+        @media (max-width: 1200px) {
+            .main-content {
+                grid-template-columns: 1fr;
+                gap: 20px;
+            }
+        }
+
+        @media (max-width: 768px) {
+            .container {
+                margin: 10px;
+                border-radius: 20px;
+            }
+            
+            .header {
+                padding: 24px 20px;
+            }
+            
+            .header h1 {
+                font-size: 1.8rem;
+            }
+            
+            .main-content {
+                padding: 20px;
+            }
+            
+            .panel {
+                padding: 20px;
+            }
+        }
+
+        /* Helper function to convert snake_case to title case */
+        .title-case {
+            text-transform: none;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <div class="header-content">
+                <img src="/static/icon.png" alt="RunAgent" class="header-icon">
+                <div class="header-text">
+                    <h1 id="agentName" class="title-case">Agent Interface</h1>
+                    <p id="agentDescription">AI Agent Testing Interface</p>
+                </div>
+            </div>
+            
+            <div class="agent-info">
+                <div class="info-item">
+                    <strong>Agent ID</strong> <span id="agentId">-</span>
+                </div>
+                <div class="info-item">
+                    <strong>Framework</strong> <span id="framework">-</span>
+                </div>
+                <div class="info-item">
+                    <strong>Port</strong> <span id="runagentPort">-</span>
+                </div>
+                <div class="info-item">
+                    <strong>Status</strong> <span id="connectionStatus">Connecting...</span>
+                </div>
+                <div class="status-badge" id="statusBadge">Agent Interface</div>
+            </div>
+        </div>
+
+        <div class="main-content">
+            <!-- Input & Testing Panel -->
+            <div class="panel">
+                <h3>Agent Testing</h3>
+                
+                <div id="dynamicInputs">
+                    <!-- Dynamic input fields will be generated here -->
+                </div>
+                
+                <div class="form-group">
+                    <label>Test Message</label>
+                    <textarea class="form-control textarea" id="testMessage" placeholder="Enter your test message..." rows="3"></textarea>
+                </div>
+                
+                <div class="form-group">
+                    <button class="btn btn-success" onclick="runTest()" id="testButton">
+                        Test Agent
+                    </button>
+                    <button class="btn btn-info" onclick="testStreaming()" id="streamButton">
+                        Live Streaming Test
+                    </button>
+                    <button class="btn btn-secondary" onclick="loadAgentInfo()">
+                        Refresh Info
+                    </button>
+                </div>
+                <div class="form-group">
+                    <div class="output info" id="inputPreview" style="font-size: 12px; max-height: 100px; overflow-y: auto;">
+                        Click "Refresh Info" to see current input values...
+                    </div>
+                </div>
+                
+                <div class="output" id="testOutput">Ready for agent testing...</div>
+            </div>
+
+            <!-- Results Panel -->
+            <div class="panel">
+                <h3>Results & Information</h3>
+                
+                <div class="tabs">
+                    <div class="tab active" onclick="switchTab('results-tab')">Results</div>
+                    <div class="tab" onclick="switchTab('info-tab')">Agent Info</div>
+                </div>
+                
+                <div id="results-tab" class="tab-content active">
+                    <div class="form-group">
+                        <button class="btn btn-info" onclick="showLastResult()">
+                            Show Last Result
+                        </button>
+                        <button class="btn btn-secondary" onclick="clearResults()">
+                            Clear Results
+                        </button>
+                    </div>
+                    <div class="output" id="resultsOutput">Test results will appear here...</div>
+                </div>
+                
+                <div id="info-tab" class="tab-content">
+                    <div class="form-group">
+                        <button class="btn btn-info" onclick="checkAgentStatus()">
+                            Check Status
+                        </button>
+                        <button class="btn btn-secondary" onclick="showAgentDetails()">
+                            Show Details
+                        </button>
+                    </div>
+                    <div class="output" id="infoOutput">Agent information will appear here...</div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let agentInfo = null;
+        let runagentUrl = null;
+        let lastTestResult = null;
+        let isStreaming = false;
+
+        // Get agent ID from URL
+        const urlParams = new URLSearchParams(window.location.search);
+        const agentId = urlParams.get('agent');
+
+        if (agentId) {
+            document.getElementById('agentId').textContent = agentId;
+        }
+
+        // Initialize the page
+        window.addEventListener('DOMContentLoaded', initializePage);
+
+        // Helper function to convert snake_case to Title Case
+        function formatTitle(text) {
+            return text
+                .split('_')
+                .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                .join(' ');
+        }
+
+        // Helper function to format field names
+        function formatFieldName(fieldName) {
+            return fieldName
+                .replace(/_/g, ' ')
+                .replace(/\b\w/g, letter => letter.toUpperCase());
+        }
+
+        async function initializePage() {
+            if (!agentId) {
+                log("No agent ID provided in URL");
+                return;
+            }
+
+            await loadAgentInfo();
+            log("Agent Interface initialized");
+        }
+
+        async function loadAgentInfo() {
+            try {
+                log('Loading agent information...');
+                
+                const response = await fetch(`http://localhost:8000/agent/${agentId}`);
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+
+                const data = await response.json();
+                agentInfo = data.agent_info;
+                runagentUrl = agentInfo.runagent_url;
+                
+                log(`Agent info loaded successfully`);
+                log(`RunAgent URL: ${runagentUrl}`);
+                
+                // Update UI with formatted titles
+                const agentName = formatTitle(agentInfo.agent_name);
+                document.getElementById('agentName').textContent = agentName;
+                document.getElementById('agentDescription').textContent = agentInfo.description;
+                document.getElementById('framework').textContent = agentInfo.framework?.toUpperCase();
+                document.getElementById('runagentPort').textContent = agentInfo.port;
+                document.getElementById('connectionStatus').textContent = 'Connected';
+                document.getElementById('connectionStatus').style.color = '#10b981';
+                
+                // Update status badge
+                document.getElementById('statusBadge').textContent = `${agentName} Active`;
+                
+                // Generate input fields
+                generateInputFields();
+                
+            } catch (error) {
+                log(`Error loading agent info: ${error.message}`);
+                document.getElementById('connectionStatus').textContent = 'Connection Failed';
+                document.getElementById('connectionStatus').style.color = '#ef4444';
+            }
+        }
+
+        function generateInputFields() {
+            const container = document.getElementById('dynamicInputs');
+            container.innerHTML = '';
+
+            if (!agentInfo || !agentInfo.input_fields) {
+                log("No input fields defined for this agent");
+                return;
+            }
+
+            const inputFields = agentInfo.input_fields || ['query'];
+            const inputTypes = agentInfo.input_types || {};
+            const inputDescriptions = agentInfo.input_descriptions || {};
+
+            inputFields.forEach((field, index) => {
+                const group = document.createElement('div');
+                group.className = 'form-group';
+
+                const label = document.createElement('label');
+                const fieldType = inputTypes[field] || 'string';
+                const description = inputDescriptions[field] || `Enter ${field}`;
+                const isRequired = index === 0;
+                
+                // Format the field name nicely
+                const formattedFieldName = formatFieldName(field);
+                label.textContent = `${formattedFieldName}${isRequired ? ' *' : ''}`;
+                if (isRequired) {
+                    label.style.fontWeight = '600';
+                    label.style.color = '#1e293b';
+                }
+
+                let input;
+                if (fieldType === 'textarea' || description.length > 50) {
+                    input = document.createElement('textarea');
+                    input.className = 'form-control textarea';
+                    input.rows = 2;
+                } else {
+                    input = document.createElement('input');
+                    input.className = 'form-control';
+                    
+                    switch (fieldType) {
+                        case 'number':
+                        case 'integer':
+                            input.type = 'number';
+                            input.value = '1';
+                            break;
+                        case 'boolean':
+                            input.type = 'checkbox';
+                            input.checked = false;
+                            break;
+                        case 'email':
+                            input.type = 'email';
+                            break;
+                        case 'url':
+                            input.type = 'url';
+                            break;
+                        default:
+                            input.type = 'text';
+                    }
+                }
+
+                input.id = field;
+                input.name = field;
+                input.placeholder = description;
+                
+                // Set default values for non-primary fields
+                if (index > 0 && fieldType === 'string' && !input.value) {
+                    input.value = `default_${field}`;
+                }
+
+                group.appendChild(label);
+                group.appendChild(input);
+                container.appendChild(group);
+            });
+
+            log(`Generated ${inputFields.length} input fields`);
+        }
+
+        function getInputData() {
+            const inputData = {};
+            
+            if (!agentInfo?.input_fields) {
+                return { query: document.getElementById('testMessage').value.trim() || 'Hello' };
+            }
+            
+            agentInfo.input_fields.forEach(field => {
+                const element = document.getElementById(field);
+                if (element) {
+                    const fieldType = agentInfo.input_types?.[field] || 'string';
+                    
+                    if (fieldType === 'boolean') {
+                        inputData[field] = element.checked;
+                    } else if (fieldType === 'number' || fieldType === 'integer') {
+                        inputData[field] = element.value ? Number(element.value) : 1;
+                    } else if (fieldType.includes('array') || fieldType.includes('list')) {
+                        const rawValue = element.value.trim();
+                        if (rawValue) {
+                            inputData[field] = rawValue.includes('\n') 
+                                ? rawValue.split('\n').map(s => s.trim()).filter(s => s)
+                                : [rawValue];
+                        } else {
+                            inputData[field] = [];
+                        }
+                    } else {
+                        inputData[field] = element.value.trim() || '';
+                    }
+                }
+            });
+            
+            // If no dynamic inputs were filled, use test message for primary field
+            const primaryField = agentInfo.input_fields[0];
+            const testMessage = document.getElementById('testMessage').value.trim();
+            
+            if (testMessage && (!inputData[primaryField] || inputData[primaryField] === '' || Array.isArray(inputData[primaryField]) && inputData[primaryField].length === 0)) {
+                if (agentInfo.input_types?.[primaryField]?.includes('array')) {
+                    inputData[primaryField] = [testMessage];
+                } else {
+                    inputData[primaryField] = testMessage;
+                }
+            }
+            
+            return inputData;
+        }
+
+        async function runTest() {
+            const testButton = document.getElementById('testButton');
+            const originalText = testButton.innerHTML;
+            
+            testButton.disabled = true;
+            testButton.innerHTML = '<span class="loading-spinner"></span>Testing...';
+            
+            const testOutput = document.getElementById('testOutput');
+            testOutput.textContent = 'Running agent test...\n';
+            testOutput.className = 'output';
+            
+            try {
+                const inputData = getInputData();
+                const testMessage = document.getElementById('testMessage').value.trim() || 'Hello, how can you help me?';
+                
+                log(`Starting agent test with inputs: ${JSON.stringify(inputData)}`);
+                log(`Test message: "${testMessage}"`);
+                
+                const params = new URLSearchParams({
+                    test_message: testMessage,
+                    input_data: JSON.stringify(inputData)
+                });
+                
+                const response = await fetch(`http://localhost:8000/agent/${agentId}/run-test?${params}`);
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+
+                const result = await response.json();
+                lastTestResult = result;
+                
+                if (result.success) {
+                    testOutput.className = 'output success';
+                    testOutput.textContent = `Agent Test Successful!\n\n${result.test_stdout}`;
+                    log(`Agent test successful`);
+                    
+                    // Show in results tab
+                    const resultsOutput = document.getElementById('resultsOutput');
+                    resultsOutput.className = 'output success';
+                    resultsOutput.textContent = `SUCCESS\n\nAgent: ${result.agent_info?.name}\nFramework: ${result.agent_info?.framework}\nPort: ${result.agent_info?.port}\n\nInputs Used:\n${JSON.stringify(inputData, null, 2)}\n\nOutput:\n${result.test_stdout}`;
+                    
+                } else {
+                    testOutput.className = 'output error';
+                    let errorMsg = `Agent Test Failed\n\n`;
+                    if (result.error) errorMsg += `Error: ${result.error}\n\n`;
+                    if (result.test_stderr) errorMsg += `Stderr: ${result.test_stderr}\n\n`;
+                    if (result.test_stdout) errorMsg += `Stdout: ${result.test_stdout}`;
+                    
+                    testOutput.textContent = errorMsg;
+                    log(`Agent test failed: ${result.error}`);
+                    
+                    // Show in info tab
+                    const infoOutput = document.getElementById('infoOutput');
+                    infoOutput.className = 'output error';
+                    infoOutput.textContent = errorMsg;
+                }
+                
+            } catch (error) {
+                testOutput.className = 'output error';
+                testOutput.textContent = `Test Error: ${error.message}\n\nCheck that the agent is running and accessible.`;
+                log(`Agent test error: ${error.message}`);
+            } finally {
+                testButton.disabled = false;
+                testButton.innerHTML = originalText;
+            }
+        }
+
+        // New live streaming function
+        async function testStreamingLive() {
+            if (isStreaming) {
+                log("Streaming already in progress");
+                return;
+            }
+
+            const streamButton = document.getElementById('streamButton');
+            const originalText = streamButton.innerHTML;
+            
+            isStreaming = true;
+            streamButton.disabled = true;
+            streamButton.innerHTML = '<span class="streaming-indicator"></span>Live Streaming...';
+            
+            const testOutput = document.getElementById('testOutput');
+            testOutput.className = 'output info';
+            testOutput.textContent = 'Starting live streaming test...\n';
+            
+            try {
+                const inputData = getInputData();
+                const testMessage = document.getElementById('testMessage').value.trim() || 'Hello, streaming test';
+                
+                log(`Starting live streaming test with inputs: ${JSON.stringify(inputData)}`);
+                
+                // Find streaming entrypoint
+                const streamingTag = agentInfo?.entrypoint_tags?.find(tag => tag.includes('stream')) || 'main_stream';
+                
+                const params = new URLSearchParams({
+                    test_message: testMessage,
+                    input_data: JSON.stringify(inputData),
+                    entrypoint_tag: streamingTag
+                });
+                
+                const response = await fetch(`http://localhost:8000/agent/${agentId}/run-test-stream?${params}`);
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                
+                testOutput.textContent = ''; // Clear previous content
+                testOutput.className = 'output info';
+                
+                let buffer = '';
+                
+                while (true) {
+                    const { done, value } = await reader.read();
+                    
+                    if (done) break;
+                    
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop(); // Keep incomplete line in buffer
+                    
+                    for (const line of lines) {
+                        if (line.startsWith('data: ')) {
+                            try {
+                                const data = JSON.parse(line.slice(6));
+                                
+                                if (data.type === 'output') {
+                                    testOutput.textContent += data.content + '\n';
+                                    testOutput.scrollTop = testOutput.scrollHeight;
+                                } else if (data.type === 'complete') {
+                                    testOutput.className = 'output success';
+                                    testOutput.textContent += '\nLive streaming completed successfully!';
+                                    log(`Live streaming completed successfully`);
+                                    return;
+                                } else if (data.type === 'error') {
+                                    testOutput.className = 'output error';
+                                    testOutput.textContent += '\nError: ' + data.content;
+                                    log(`Live streaming error: ${data.content}`);
+                                    return;
+                                }
+                            } catch (e) {
+                                // Skip parsing errors for incomplete JSON
+                            }
+                        }
+                    }
+                }
+                
+                // Handle any remaining buffer content
+                if (buffer && buffer.startsWith('data: ')) {
+                    try {
+                        const data = JSON.parse(buffer.slice(6));
+                        if (data.type === 'output') {
+                            testOutput.textContent += data.content + '\n';
+                        }
+                    } catch (e) {
+                        // Ignore parsing errors
+                    }
+                }
+                
+            } catch (error) {
+                testOutput.className = 'output error';
+                testOutput.textContent = `Live Streaming Error: ${error.message}`;
+                log(`Live streaming error: ${error.message}`);
+            } finally {
+                isStreaming = false;
+                streamButton.disabled = false;
+                streamButton.innerHTML = originalText;
+            }
+        }
+
+        // Updated testStreaming function to use live streaming
+        async function testStreaming() {
+            await testStreamingLive();
+        }
+
+        async function checkAgentStatus() {
+            try {
+                const response = await fetch(`http://localhost:8000/agent/${agentId}`);
+                const data = await response.json();
+                
+                const infoOutput = document.getElementById('infoOutput');
+                infoOutput.className = 'output success';
+                infoOutput.textContent = `Agent Status Check:\n\n${JSON.stringify(data, null, 2)}`;
+                
+                log("Agent status check completed");
+            } catch (error) {
+                log(`Status check failed: ${error.message}`);
+            }
+        }
+
+        function showAgentDetails() {
+            if (agentInfo) {
+                const infoOutput = document.getElementById('infoOutput');
+                infoOutput.className = 'output info';
+                const formattedName = formatTitle(agentInfo.agent_name);
+                infoOutput.textContent = `Agent Details:
+
+Name: ${formattedName}
+Description: ${agentInfo.description}
+Framework: ${agentInfo.framework}
+Port: ${agentInfo.port}
+Input Fields: ${agentInfo.input_fields?.map(field => formatFieldName(field)).join(', ') || 'None'}
+Entrypoints: ${agentInfo.entrypoint_tags?.join(', ') || 'None'}
+Expected Output: ${agentInfo.expected_output_format || 'String response'}
+
+Connection Info:
+- Agent ID: ${agentId}
+- RunAgent URL: ${runagentUrl}
+- Status: ${agentInfo.status || 'Active'}`;
+            } else {
+                const infoOutput = document.getElementById('infoOutput');
+                infoOutput.className = 'output';
+                infoOutput.textContent = 'No agent information available. Try refreshing.';
+            }
+        }
+
+        function showLastResult() {
+            if (lastTestResult) {
+                const resultsOutput = document.getElementById('resultsOutput');
+                resultsOutput.className = lastTestResult.success ? 'output success' : 'output error';
+                resultsOutput.textContent = JSON.stringify(lastTestResult, null, 2);
+            } else {
+                const resultsOutput = document.getElementById('resultsOutput');
+                resultsOutput.className = 'output';
+                resultsOutput.textContent = 'No test results available yet. Run a test first.';
+            }
+        }
+
+        function clearResults() {
+            document.getElementById('resultsOutput').textContent = 'Test results cleared.';
+            document.getElementById('resultsOutput').className = 'output';
+            lastTestResult = null;
+        }
+
+        function switchTab(tabId) {
+            // Hide all tab contents
+            document.querySelectorAll('.tab-content').forEach(tab => {
+                tab.classList.remove('active');
+            });
+            
+            // Remove active class from all tabs
+            document.querySelectorAll('.tab').forEach(tab => {
+                tab.classList.remove('active');
+            });
+            
+            // Show selected tab
+            document.getElementById(tabId).classList.add('active');
+            
+            // Add active class to clicked tab
+            event.target.classList.add('active');
+        }
+
+        function log(message) {
+            console.log(`[${new Date().toLocaleTimeString()}] ${message}`);
+        }
+    </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/examples/Vibe_Agent_Builder_gpt_5/static/icon.png b/examples/Vibe_Agent_Builder_gpt_5/static/icon.png
new file mode 100644
index 0000000..d110f8a
Binary files /dev/null and b/examples/Vibe_Agent_Builder_gpt_5/static/icon.png differ
diff --git a/examples/Vibe_Agent_Builder_gpt_5/static/index.html b/examples/Vibe_Agent_Builder_gpt_5/static/index.html
new file mode 100644
index 0000000..29bf497
--- /dev/null
+++ b/examples/Vibe_Agent_Builder_gpt_5/static/index.html
@@ -0,0 +1,1152 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>RunAgent Generator - AI Agent Builder</title>
+    <script src="https://cdn.jsdelivr.net/npm/mermaid@9.4.3/dist/mermaid.min.js"></script>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Inter', sans-serif;
+            background: linear-gradient(135deg, #1e293b 0%, #334155 100%);
+            min-height: 100vh;
+            overflow-x: hidden;
+            color: #1e293b;
+        }
+
+        .app-container {
+            display: flex;
+            min-height: 100vh;
+        }
+
+        /* Sidebar */
+        .sidebar {
+            width: 280px;
+            background: rgba(255, 255, 255, 0.95);
+            backdrop-filter: blur(10px);
+            border-right: 1px solid rgba(0, 0, 0, 0.1);
+            display: flex;
+            flex-direction: column;
+            transition: transform 0.3s ease;
+        }
+
+        .sidebar-header {
+            padding: 24px 20px;
+            border-bottom: 1px solid rgba(0, 0, 0, 0.1);
+        }
+
+        .sidebar-header h2 {
+            font-size: 1.2rem;
+            font-weight: 600;
+            color: #1e293b;
+            margin-bottom: 8px;
+        }
+
+        .sidebar-header p {
+            font-size: 0.85rem;
+            color: #64748b;
+            line-height: 1.4;
+        }
+
+        .new-chat-btn {
+            width: 100%;
+            padding: 12px 16px;
+            background: linear-gradient(135deg, #3b82f6, #1d4ed8);
+            color: white;
+            border: none;
+            border-radius: 12px;
+            font-size: 14px;
+            font-weight: 500;
+            cursor: pointer;
+            margin: 16px 20px;
+            width: calc(100% - 40px);
+            transition: all 0.2s ease;
+            box-shadow: 0 4px 12px rgba(59, 130, 246, 0.3);
+        }
+
+        .new-chat-btn:hover {
+            transform: translateY(-1px);
+            box-shadow: 0 6px 20px rgba(59, 130, 246, 0.4);
+        }
+
+        .chat-list {
+            flex: 1;
+            overflow-y: auto;
+            padding: 0 12px;
+        }
+
+        .chat-item {
+            padding: 12px 16px;
+            margin: 4px 0;
+            border-radius: 12px;
+            cursor: pointer;
+            transition: all 0.2s ease;
+            border: 2px solid transparent;
+        }
+
+        .chat-item:hover {
+            background: rgba(59, 130, 246, 0.08);
+            border-color: rgba(59, 130, 246, 0.2);
+        }
+
+        .chat-item.active {
+            background: rgba(59, 130, 246, 0.12);
+            border-color: #3b82f6;
+        }
+
+        .chat-item-title {
+            font-size: 14px;
+            font-weight: 500;
+            color: #1e293b;
+            margin-bottom: 4px;
+            line-height: 1.3;
+        }
+
+        .chat-item-preview {
+            font-size: 12px;
+            color: #64748b;
+            line-height: 1.3;
+        }
+
+        .chat-item-status {
+            font-size: 11px;
+            margin-top: 6px;
+            padding: 2px 8px;
+            border-radius: 6px;
+            display: inline-block;
+            font-weight: 500;
+        }
+
+        .status-understanding { background: #fef3c7; color: #92400e; }
+        .status-planning { background: #dbeafe; color: #1e40af; }
+        .status-generating { background: #fde68a; color: #b45309; }
+        .status-complete { background: #d1fae5; color: #065f46; }
+
+        /* Main Content */
+        .main-content {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            background: white;
+            margin: 20px 20px 20px 0;
+            border-radius: 20px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+            overflow: hidden;
+            max-height: calc(100vh - 40px);
+        }
+
+        .header {
+            background: linear-gradient(135deg, #f8fafc 0%, #e2e8f0 100%);
+            padding: 24px 32px;
+            border-bottom: 1px solid rgba(0, 0, 0, 0.08);
+        }
+
+        .header h1 {
+            font-size: 1.8rem;
+            margin-bottom: 8px;
+            font-weight: 600;
+            color: #1e293b;
+            letter-spacing: -0.02em;
+        }
+
+        .header p {
+            font-size: 1rem;
+            color: #64748b;
+            margin-bottom: 0;
+        }
+
+        .content-area {
+            flex: 1;
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 24px;
+            padding: 24px 32px;
+            overflow-y: auto;
+            min-height: 0;
+        }
+
+        .chat-panel {
+            display: flex;
+            flex-direction: column;
+            min-height: 0;
+            height: fit-content;
+            max-height: 80vh;
+        }
+
+        .chat-messages {
+            flex: 1;
+            overflow-y: auto;
+            padding: 20px;
+            background: #f8fafc;
+            border-radius: 16px;
+            margin-bottom: 20px;
+            border: 1px solid #e2e8f0;
+        }
+
+        .message {
+            margin-bottom: 16px;
+            padding: 14px 18px;
+            border-radius: 16px;
+            max-width: 85%;
+            animation: fadeIn 0.3s ease;
+            line-height: 1.5;
+        }
+
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(10px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+
+        .message.user {
+            background: linear-gradient(135deg, #3b82f6, #1d4ed8);
+            color: white;
+            margin-left: auto;
+            border-bottom-right-radius: 6px;
+        }
+
+        .message.assistant {
+            background: white;
+            border: 1px solid #e2e8f0;
+            border-bottom-left-radius: 6px;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.08);
+            color: #374151;
+        }
+
+        .message.system {
+            background: #eff6ff;
+            border: 1px solid #bfdbfe;
+            text-align: center;
+            font-style: italic;
+            color: #1e40af;
+            max-width: 100%;
+        }
+
+        .typing-indicator {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            background: white;
+            border: 1px solid #e2e8f0;
+            padding: 14px 18px;
+            border-radius: 16px;
+            border-bottom-left-radius: 6px;
+            max-width: 80px;
+        }
+
+        .typing-dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background: #9ca3af;
+            animation: typing 1.4s infinite ease-in-out;
+        }
+
+        .typing-dot:nth-child(2) { animation-delay: 0.2s; }
+        .typing-dot:nth-child(3) { animation-delay: 0.4s; }
+
+        @keyframes typing {
+            0%, 60%, 100% { transform: translateY(0); opacity: 0.4; }
+            30% { transform: translateY(-8px); opacity: 1; }
+        }
+
+        .input-container {
+            display: flex;
+            gap: 12px;
+            align-items: flex-end;
+        }
+
+        .chat-input {
+            flex: 1;
+            padding: 14px 18px;
+            border: 2px solid #e2e8f0;
+            border-radius: 20px;
+            font-size: 14px;
+            resize: none;
+            max-height: 120px;
+            background: white;
+            transition: border-color 0.3s ease;
+            font-family: inherit;
+        }
+
+        .chat-input:focus {
+            outline: none;
+            border-color: #3b82f6;
+            box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1);
+        }
+
+        .send-button {
+            width: 44px;
+            height: 44px;
+            border: none;
+            border-radius: 50%;
+            background: linear-gradient(135deg, #3b82f6, #1d4ed8);
+            color: white;
+            cursor: pointer;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 16px;
+            transition: transform 0.2s ease, box-shadow 0.2s ease;
+            flex-shrink: 0;
+        }
+
+        .send-button:hover:not(:disabled) {
+            transform: translateY(-1px);
+            box-shadow: 0 6px 16px rgba(59, 130, 246, 0.4);
+        }
+
+        .send-button:disabled {
+            background: #9ca3af;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        .preview-panel {
+            display: flex;
+            flex-direction: column;
+            gap: 20px;
+            min-height: 0;
+            height: fit-content;
+        }
+
+        .stage-indicator {
+            display: flex;
+            gap: 8px;
+            margin-bottom: 20px;
+            background: #f1f5f9;
+            padding: 8px;
+            border-radius: 16px;
+        }
+
+        .stage {
+            flex: 1;
+            text-align: center;
+            padding: 10px 8px;
+            border-radius: 12px;
+            font-size: 13px;
+            font-weight: 500;
+            background: white;
+            color: #64748b;
+            transition: all 0.3s ease;
+            border: 1px solid #e2e8f0;
+        }
+
+        .stage.active {
+            background: linear-gradient(135deg, #3b82f6, #1d4ed8);
+            color: white;
+            border-color: #3b82f6;
+            transform: translateY(-1px);
+            box-shadow: 0 4px 12px rgba(59, 130, 246, 0.3);
+        }
+
+        .stage.completed {
+            background: linear-gradient(135deg, #10b981, #059669);
+            color: white;
+            border-color: #10b981;
+        }
+
+        .description-section {
+            background: #f8fafc;
+            padding: 20px;
+            border-radius: 16px;
+            border: 1px solid #e2e8f0;
+            border-left: 4px solid #3b82f6;
+        }
+
+        .description-section h3 {
+            color: #1e293b;
+            margin-bottom: 12px;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 1.1rem;
+            font-weight: 600;
+        }
+
+        .diagram-section {
+            background: white;
+            padding: 20px;
+            border-radius: 16px;
+            border: 1px solid #e2e8f0;
+            min-height: 300px;
+            max-height: none;
+            overflow: visible;
+        }
+
+        .diagram-section h3 {
+            color: #1e293b;
+            margin-bottom: 16px;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 1.1rem;
+            font-weight: 600;
+        }
+
+        #mermaid-diagram {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            min-height: 250px;
+            color: #64748b;
+            font-style: italic;
+        }
+
+        .agent-result {
+            background: linear-gradient(135deg, #10b981, #059669);
+            color: white;
+            padding: 24px;
+            border-radius: 16px;
+            text-align: center;
+        }
+
+        .agent-result h3 {
+            margin-bottom: 16px;
+            font-size: 1.3rem;
+            font-weight: 600;
+        }
+
+        .agent-info {
+            background: rgba(255,255,255,0.15);
+            padding: 16px;
+            border-radius: 12px;
+            margin: 12px 0;
+            backdrop-filter: blur(10px);
+            border: 1px solid rgba(255,255,255,0.2);
+        }
+
+        .agent-url {
+            display: inline-block;
+            background: white;
+            color: #10b981;
+            padding: 12px 24px;
+            border-radius: 24px;
+            text-decoration: none;
+            font-weight: 500;
+            margin-top: 12px;
+            transition: transform 0.2s ease;
+        }
+
+        .agent-url:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 6px 20px rgba(0,0,0,0.2);
+        }
+
+        .examples-section {
+            padding: 20px 32px;
+            border-top: 1px solid #e2e8f0;
+            background: #f8fafc;
+        }
+
+        .examples-title {
+            font-size: 14px;
+            font-weight: 600;
+            color: #374151;
+            margin-bottom: 12px;
+            text-align: center;
+        }
+
+        .examples {
+            display: flex;
+            gap: 8px;
+            flex-wrap: wrap;
+            justify-content: center;
+        }
+
+        .example-chip {
+            background: white;
+            color: #374151;
+            padding: 8px 16px;
+            border-radius: 16px;
+            font-size: 13px;
+            cursor: pointer;
+            transition: all 0.2s ease;
+            border: 1px solid #e2e8f0;
+            font-weight: 500;
+        }
+
+        .example-chip:hover {
+            background: #3b82f6;
+            color: white;
+            border-color: #3b82f6;
+            transform: translateY(-1px);
+            box-shadow: 0 4px 12px rgba(59, 130, 246, 0.3);
+        }
+
+        .sidebar-toggle {
+            display: none;
+            position: fixed;
+            top: 20px;
+            left: 20px;
+            z-index: 1000;
+            background: white;
+            border: 1px solid #e2e8f0;
+            border-radius: 8px;
+            padding: 8px;
+            cursor: pointer;
+            box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+        }
+
+        /* Scrollbar styling */
+        .chat-messages::-webkit-scrollbar,
+        .chat-list::-webkit-scrollbar,
+        .content-area::-webkit-scrollbar {
+            width: 6px;
+        }
+
+        .chat-messages::-webkit-scrollbar-track,
+        .chat-list::-webkit-scrollbar-track,
+        .content-area::-webkit-scrollbar-track {
+            background: transparent;
+        }
+
+        .chat-messages::-webkit-scrollbar-thumb,
+        .chat-list::-webkit-scrollbar-thumb,
+        .content-area::-webkit-scrollbar-thumb {
+            background: #cbd5e1;
+            border-radius: 3px;
+        }
+
+        .chat-messages::-webkit-scrollbar-thumb:hover,
+        .chat-list::-webkit-scrollbar-thumb:hover,
+        .content-area::-webkit-scrollbar-thumb:hover {
+            background: #94a3b8;
+        }
+
+        @media (max-width: 768px) {
+            .sidebar {
+                position: fixed;
+                top: 0;
+                left: 0;
+                height: 100vh;
+                z-index: 999;
+                transform: translateX(-100%);
+            }
+            
+            .sidebar.open {
+                transform: translateX(0);
+            }
+            
+            .main-content {
+                margin: 20px;
+                border-radius: 16px;
+            }
+            
+            .content-area {
+                grid-template-columns: 1fr;
+                gap: 16px;
+                padding: 20px;
+            }
+            
+            .sidebar-toggle {
+                display: block;
+            }
+            
+            .examples {
+                flex-direction: column;
+                align-items: center;
+            }
+            
+            .example-chip {
+                width: 100%;
+                max-width: 280px;
+                text-align: center;
+            }
+        }
+
+        /* Mermaid styling */
+        .mermaid {
+            max-width: 100%;
+        }
+
+        .mermaid svg {
+            max-width: 100%;
+            height: auto;
+        }
+    </style>
+</head>
+<body>
+    <div class="app-container">
+        <!-- Sidebar -->
+        <div class="sidebar" id="sidebar">
+            <div class="sidebar-header">
+                <div style="display: flex; align-items: center; gap: 12px; margin-bottom: 12px;">
+                    <img src="/static/icon.png" alt="RunAgent" style="width: 32px; height: 32px; border-radius: 8px;">
+                    <h2 style="margin: 0;">RunAgent Generator</h2>
+                </div>
+                <p>Build powerful AI agents with natural language</p>
+            </div>
+            
+            <button class="new-chat-btn" onclick="createNewChat()">
+                New Agent Chat
+            </button>
+            
+            <div class="chat-list" id="chatList">
+                <!-- Chat items will be populated here -->
+            </div>
+        </div>
+
+        <!-- Mobile sidebar toggle -->
+        <div class="sidebar-toggle" onclick="toggleSidebar()">
+            <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                <line x1="3" y1="6" x2="21" y2="6"></line>
+                <line x1="3" y1="12" x2="21" y2="12"></line>
+                <line x1="3" y1="18" x2="21" y2="18"></line>
+            </svg>
+        </div>
+
+        <!-- Main Content -->
+        <div class="main-content">
+            <div class="header">
+                <div style="display: flex; align-items: center; gap: 16px;">
+                    <img src="/static/icon.png" alt="RunAgent" style="width: 40px; height: 40px; border-radius: 10px;">
+                    <div>
+                        <h1>AI Agent Builder</h1>
+                        <p>Describe your agent requirements and we'll build it for you</p>
+                    </div>
+                </div>
+            </div>
+
+            <div class="content-area">
+                <!-- Chat Panel -->
+                <div class="chat-panel">
+                    <div class="chat-messages" id="chatMessages">
+                        <div class="message assistant">
+                            <strong>Welcome to RunAgent Generator</strong><br><br>
+                            I can help you create custom AI agents using natural language. Just tell me what kind of agent you want!<br><br>
+                            <strong>Examples:</strong><br>
+                            • "I want a weather agent in LangGraph"<br>
+                            • "Create a research assistant using Letta"<br>
+                            • "Build a math solver with LlamaIndex"<br>
+                            • "Make a content writer agent in Agno"
+                        </div>
+                    </div>
+                    
+                    <div class="input-container">
+                        <textarea 
+                            id="chatInput" 
+                            class="chat-input" 
+                            placeholder="Describe the AI agent you want to create..."
+                            rows="1"
+                        ></textarea>
+                        <button id="sendButton" class="send-button">
+                            <span>→</span>
+                        </button>
+                    </div>
+                </div>
+
+                <!-- Preview Panel -->
+                <div class="preview-panel">
+                    <div class="stage-indicator">
+                        <div class="stage" id="stage-understanding">Understanding</div>
+                        <div class="stage" id="stage-planning">Planning</div>
+                        <div class="stage" id="stage-generating">Generating</div>
+                        <div class="stage" id="stage-complete">Complete</div>
+                    </div>
+
+                    <div class="description-section" id="descriptionSection" style="display: none;">
+                        <h3>Agent Description</h3>
+                        <div id="agentDescription">
+                            <!-- Agent description will appear here -->
+                        </div>
+                    </div>
+
+                    <div class="diagram-section" id="diagramSection" style="display: none;">
+                        <h3>
+                            <span>Workflow Diagram</span>
+                            <div class="zoom-controls" id="zoomControls">
+                                <button class="zoom-btn" onclick="zoomDiagram(-0.2)" title="Zoom Out">−</button>
+                                <span class="zoom-level" id="zoomLevel">100%</span>
+                                <button class="zoom-btn" onclick="zoomDiagram(0.2)" title="Zoom In">+</button>
+                                <button class="zoom-btn" onclick="resetZoom()" title="Reset Zoom" style="margin-left: 8px; font-size: 12px;">⌂</button>
+                            </div>
+                        </h3>
+                        <div class="diagram-container">
+                            <div class="diagram-viewport" id="diagramViewport">
+                                <div id="mermaid-diagram">
+                                    Workflow diagram will appear here...
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="agent-result" id="agentResult" style="display: none;">
+                        <h3>Your Agent is Ready</h3>
+                        <div class="agent-info">
+                            <div><strong>Agent ID:</strong> <span id="agentId">-</span></div>
+                            <div style="margin-top: 10px;">
+                                <a href="#" id="agentUrl" class="agent-url" target="_blank">
+                                    Open Agent Interface
+                                </a>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <div class="examples-section">
+                <div class="examples-title">Try these examples to get started</div>
+                <div class="examples">
+                    <div class="example-chip" onclick="sendExample('I want a weather agent in LangGraph')">
+                        Weather Agent
+                    </div>
+                    <div class="example-chip" onclick="sendExample('Create a research assistant using Letta')">
+                        Research Assistant  
+                    </div>
+                    <div class="example-chip" onclick="sendExample('Build a math solver with LlamaIndex')">
+                        Math Solver
+                    </div>
+                    <div class="example-chip" onclick="sendExample('Make a content writer agent in Agno')">
+                        Content Writer
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let currentChatId = null;
+        let chats = {};
+        let isTyping = false;
+        let currentZoom = 1;
+        let minZoom = 0.3;
+        let maxZoom = 3;
+
+        const chatMessages = document.getElementById('chatMessages');
+        const chatInput = document.getElementById('chatInput');
+        const sendButton = document.getElementById('sendButton');
+
+        // Initialize mermaid
+        mermaid.initialize({ 
+            startOnLoad: true,
+            theme: 'default',
+            flowchart: {
+                useMaxWidth: true,
+                htmlLabels: true
+            }
+        });
+
+        // Initialize with first chat
+        window.addEventListener('DOMContentLoaded', () => {
+            createNewChat();
+        });
+
+        // Auto-resize textarea
+        chatInput.addEventListener('input', function() {
+            this.style.height = 'auto';
+            this.style.height = Math.min(this.scrollHeight, 120) + 'px';
+        });
+
+        // Send message on Enter
+        chatInput.addEventListener('keydown', function(e) {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                sendMessage();
+            }
+        });
+
+        sendButton.addEventListener('click', sendMessage);
+
+        function createNewChat() {
+            const chatId = 'chat_' + Date.now();
+            const chat = {
+                id: chatId,
+                title: 'New Agent',
+                messages: [],
+                stage: 'understanding',
+                sessionId: null,
+                lastMessage: 'Start building your AI agent...',
+                agentInfo: null
+            };
+            
+            chats[chatId] = chat;
+            switchToChat(chatId);
+            updateChatList();
+        }
+
+        function switchToChat(chatId) {
+            if (currentChatId === chatId) return;
+            
+            // Save current chat state if exists
+            if (currentChatId && chats[currentChatId]) {
+                saveChatState();
+            }
+            
+            currentChatId = chatId;
+            const chat = chats[chatId];
+            
+            // COMPLETE UI RESET for new chat
+            chatMessages.innerHTML = '';
+            chatInput.value = '';
+            chatInput.style.height = 'auto';
+            
+            // Reset all preview panels to initial state
+            resetPreviewPanelCompletely();
+            
+            // Reset stage to understanding
+            updateStage('understanding');
+            
+            // Load chat messages
+            if (chat.messages.length === 0) {
+                // Add welcome message for new chat
+                addMessage(`
+                    <strong>Welcome to RunAgent Generator</strong><br><br>
+                    I can help you create custom AI agents using natural language. Just tell me what kind of agent you want!<br><br>
+                    <strong>Examples:</strong><br>
+                    • "I want a weather agent in LangGraph"<br>
+                    • "Create a research assistant using Letta"<br>
+                    • "Build a math solver with LlamaIndex"<br>
+                    • "Make a content writer agent in Agno"
+                `, 'assistant');
+            } else {
+                chat.messages.forEach(msg => {
+                    addMessage(msg.content, msg.type, false);
+                });
+                
+                // Update stage to saved stage
+                updateStage(chat.stage);
+                
+                // Restore agent info if available
+                if (chat.agentInfo) {
+                    if (chat.agentInfo.description) {
+                        updateDescription(chat.agentInfo.description);
+                    }
+                    if (chat.agentInfo.mermaid_diagram) {
+                        updateDiagram(chat.agentInfo.mermaid_diagram);
+                    }
+                    if (chat.stage === 'complete' && chat.agentInfo.agent_id && chat.agentInfo.agent_url) {
+                        showAgentResult(chat.agentInfo.agent_id, chat.agentInfo.agent_url);
+                    }
+                }
+            }
+            
+            updateChatList();
+            
+            // Close sidebar on mobile after selection
+            if (window.innerWidth <= 768) {
+                toggleSidebar();
+            }
+        }
+
+        function resetPreviewPanelCompletely() {
+            // Hide all sections
+            document.getElementById('descriptionSection').style.display = 'none';
+            document.getElementById('diagramSection').style.display = 'none';
+            document.getElementById('agentResult').style.display = 'none';
+            
+            // Clear content
+            document.getElementById('agentDescription').innerHTML = '';
+            document.getElementById('mermaid-diagram').innerHTML = 'Workflow diagram will appear here...';
+            document.getElementById('agentId').textContent = '-';
+            document.getElementById('agentUrl').href = '#';
+            
+            // Hide zoom controls and reset zoom
+            document.getElementById('zoomControls').classList.remove('visible');
+            resetZoom();
+            
+            // Reset all stages to initial state
+            document.querySelectorAll('.stage').forEach(s => {
+                s.classList.remove('active', 'completed');
+            });
+        }
+
+        function saveChatState() {
+            if (!currentChatId || !chats[currentChatId]) return;
+            
+            const chat = chats[currentChatId];
+            // Messages are already saved when sent, just update other state if needed
+        }
+
+        function updateChatList() {
+            const chatList = document.getElementById('chatList');
+            chatList.innerHTML = '';
+            
+            Object.values(chats).reverse().forEach(chat => {
+                const chatItem = document.createElement('div');
+                chatItem.className = `chat-item ${chat.id === currentChatId ? 'active' : ''}`;
+                chatItem.onclick = () => switchToChat(chat.id);
+                
+                const statusClass = `status-${chat.stage}`;
+                const statusText = chat.stage.charAt(0).toUpperCase() + chat.stage.slice(1);
+                
+                chatItem.innerHTML = `
+                    <div class="chat-item-title">${chat.title}</div>
+                    <div class="chat-item-preview">${chat.lastMessage}</div>
+                    <div class="chat-item-status ${statusClass}">${statusText}</div>
+                `;
+                
+                chatList.appendChild(chatItem);
+            });
+        }
+
+        function updateChatTitle(chatId, title) {
+            if (chats[chatId]) {
+                chats[chatId].title = title;
+                updateChatList();
+            }
+        }
+
+        function sendExample(text) {
+            chatInput.value = text;
+            sendMessage();
+        }
+
+        function addMessage(content, type = 'user', saveToChat = true) {
+            const messageDiv = document.createElement('div');
+            messageDiv.className = `message ${type}`;
+            
+            if (type === 'assistant') {
+                content = content.replace(
+                    /(https?:\/\/[^\s]+)/g, 
+                    '<a href="$1" target="_blank" style="color: #3b82f6; text-decoration: underline;">$1</a>'
+                );
+            }
+            
+            messageDiv.innerHTML = content.replace(/\n/g, '<br>');
+            chatMessages.appendChild(messageDiv);
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+            
+            // Save to current chat
+            if (saveToChat && currentChatId && chats[currentChatId]) {
+                chats[currentChatId].messages.push({
+                    content: content,
+                    type: type,
+                    timestamp: new Date().toISOString()
+                });
+                
+                // Update last message preview
+                if (type === 'user') {
+                    chats[currentChatId].lastMessage = content.substring(0, 50) + (content.length > 50 ? '...' : '');
+                    
+                    // Try to extract agent name from user message for title
+                    const agentMatch = content.match(/(?:create|build|make|want)\s+(?:a|an)?\s*([^.!?]*?)(?:\s+(?:agent|assistant|bot|tool))?(?:\s+(?:in|using|with)\s+\w+)?/i);
+                    if (agentMatch && agentMatch[1]) {
+                        const potentialTitle = agentMatch[1].trim();
+                        if (potentialTitle.length > 3 && potentialTitle.length < 30) {
+                            updateChatTitle(currentChatId, potentialTitle.charAt(0).toUpperCase() + potentialTitle.slice(1));
+                        }
+                    }
+                }
+                
+                updateChatList();
+            }
+        }
+
+        function showTypingIndicator() {
+            const typingDiv = document.createElement('div');
+            typingDiv.className = 'typing-indicator';
+            typingDiv.id = 'typing-indicator';
+            typingDiv.innerHTML = '<div class="typing-dot"></div><div class="typing-dot"></div><div class="typing-dot"></div>';
+            chatMessages.appendChild(typingDiv);
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+
+        function hideTypingIndicator() {
+            const typingIndicator = document.getElementById('typing-indicator');
+            if (typingIndicator) {
+                typingIndicator.remove();
+            }
+        }
+
+        function updateStage(stage) {
+            document.querySelectorAll('.stage').forEach(s => {
+                s.classList.remove('active', 'completed');
+            });
+
+            const stages = ['understanding', 'planning', 'generating', 'complete'];
+            const currentIndex = stages.indexOf(stage);
+            
+            for (let i = 0; i < currentIndex; i++) {
+                document.getElementById(`stage-${stages[i]}`).classList.add('completed');
+            }
+            
+            if (currentIndex >= 0) {
+                document.getElementById(`stage-${stage}`).classList.add('active');
+            }
+
+            // Update current chat stage
+            if (currentChatId && chats[currentChatId]) {
+                chats[currentChatId].stage = stage;
+                updateChatList();
+            }
+        }
+
+        function resetPreviewPanel() {
+            document.getElementById('descriptionSection').style.display = 'none';
+            document.getElementById('diagramSection').style.display = 'none';
+            document.getElementById('agentResult').style.display = 'none';
+            document.getElementById('mermaid-diagram').innerHTML = 'Workflow diagram will appear here...';
+            document.getElementById('zoomControls').classList.remove('visible');
+            resetZoom();
+        }
+
+        function updateDescription(description) {
+            document.getElementById('agentDescription').innerHTML = description.replace(/\n/g, '<br>');
+            document.getElementById('descriptionSection').style.display = 'block';
+        }
+
+        function updateDiagram(mermaidCode) {
+            const diagramElement = document.getElementById('mermaid-diagram');
+            
+            diagramElement.innerHTML = '';
+            
+            const cleanCode = mermaidCode
+                .replace(/```mermaid/g, '')
+                .replace(/```/g, '')
+                .trim();
+            
+            const div = document.createElement('div');
+            div.className = 'mermaid';
+            div.textContent = cleanCode;
+            diagramElement.appendChild(div);
+            
+            mermaid.init(undefined, div);
+            
+            document.getElementById('diagramSection').style.display = 'block';
+            
+            // Show zoom controls and reset zoom
+            document.getElementById('zoomControls').classList.add('visible');
+            resetZoom();
+        }
+
+        function zoomDiagram(delta) {
+            const newZoom = Math.max(minZoom, Math.min(maxZoom, currentZoom + delta));
+            if (newZoom !== currentZoom) {
+                currentZoom = newZoom;
+                applyZoom();
+            }
+        }
+
+        function resetZoom() {
+            currentZoom = 1;
+            applyZoom();
+        }
+
+        function applyZoom() {
+            const diagramElement = document.getElementById('mermaid-diagram');
+            const mermaidElement = diagramElement.querySelector('.mermaid');
+            
+            if (mermaidElement) {
+                mermaidElement.style.transform = `scale(${currentZoom})`;
+            }
+            
+            // Update zoom level display
+            document.getElementById('zoomLevel').textContent = `${Math.round(currentZoom * 100)}%`;
+            
+            // Adjust container height based on zoom
+            const viewport = document.getElementById('diagramViewport');
+            if (currentZoom < 1) {
+                viewport.style.maxHeight = '400px';
+            } else if (currentZoom > 1.5) {
+                viewport.style.maxHeight = '600px';
+            } else {
+                viewport.style.maxHeight = '500px';
+            }
+        }
+
+        function showAgentResult(agentId, agentUrl) {
+            document.getElementById('agentId').textContent = agentId;
+            document.getElementById('agentUrl').href = agentUrl;
+            document.getElementById('agentResult').style.display = 'block';
+        }
+
+        async function sendMessage() {
+            const message = chatInput.value.trim();
+            if (!message || isTyping || !currentChatId) return;
+
+            addMessage(message, 'user');
+            chatInput.value = '';
+            chatInput.style.height = 'auto';
+
+            isTyping = true;
+            sendButton.disabled = true;
+            showTypingIndicator();
+
+            try {
+                const chat = chats[currentChatId];
+                const response = await fetch('http://localhost:8000/chat', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        message: message,
+                        session_id: chat.sessionId
+                    }),
+                });
+
+                const data = await response.json();
+                
+                // Update session ID
+                chat.sessionId = data.session_id;
+
+                hideTypingIndicator();
+                addMessage(data.response, 'assistant');
+
+                updateStage(data.stage);
+
+                // Store agent info
+                if (!chat.agentInfo) {
+                    chat.agentInfo = {};
+                }
+
+                if (data.description) {
+                    chat.agentInfo.description = data.description;
+                    updateDescription(data.description);
+                }
+
+                if (data.mermaid_diagram) {
+                    chat.agentInfo.mermaid_diagram = data.mermaid_diagram;
+                    updateDiagram(data.mermaid_diagram);
+                }
+
+                if (data.stage === 'complete' && data.agent_id && data.agent_url) {
+                    chat.agentInfo.agent_id = data.agent_id;
+                    chat.agentInfo.agent_url = data.agent_url;
+                    showAgentResult(data.agent_id, data.agent_url);
+                    
+                    // Update chat title with agent name if available
+                    if (data.agent_name) {
+                        updateChatTitle(currentChatId, data.agent_name);
+                    }
+                }
+
+            } catch (error) {
+                hideTypingIndicator();
+                addMessage(`Error: ${error.message}`, 'system');
+            } finally {
+                isTyping = false;
+                sendButton.disabled = false;
+            }
+        }
+
+        function toggleSidebar() {
+            const sidebar = document.getElementById('sidebar');
+            sidebar.classList.toggle('open');
+        }
+
+        // Close sidebar when clicking outside on mobile
+        document.addEventListener('click', (e) => {
+            if (window.innerWidth <= 768) {
+                const sidebar = document.getElementById('sidebar');
+                const sidebarToggle = document.querySelector('.sidebar-toggle');
+                
+                if (!sidebar.contains(e.target) && !sidebarToggle.contains(e.target)) {
+                    sidebar.classList.remove('open');
+                }
+            }
+        });
+
+        // Initialize first stage
+        setTimeout(() => {
+            updateStage('understanding');
+        }, 500);
+    </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/examples/Vibe_Agent_Builder_gpt_5/test_sdk.py b/examples/Vibe_Agent_Builder_gpt_5/test_sdk.py
new file mode 100644
index 0000000..870d801
--- /dev/null
+++ b/examples/Vibe_Agent_Builder_gpt_5/test_sdk.py
@@ -0,0 +1,79 @@
+# test_agent_sdk.py
+# Run this script to see what the SDK response looks like
+
+from runagent import RunAgentClient
+import json
+
+def test_agent(agent_id, port=8450):
+    """Test the agent with SDK and show detailed output"""
+    
+    print(f"🧪 Testing Agent: {agent_id}")
+    print(f"🔌 Port: {port}")
+    print("=" * 50)
+    
+    try:
+        # Create client - try different entrypoint tags
+        entrypoint_tags = ["main", "generic", "basic", "invoke"]
+        
+        for tag in entrypoint_tags:
+            print(f"\n🎯 Trying entrypoint tag: '{tag}'")
+            
+            try:
+                ra = RunAgentClient(
+                    agent_id=agent_id,
+                    entrypoint_tag=tag,
+                    local=True
+                )
+                
+                print(f"✅ Client created successfully with tag: {tag}")
+                
+                # Test with minimal input
+                test_inputs = [
+                    {"math_query": "What is 3*3?"}
+                ]
+                
+                for test_input in test_inputs:
+                    try:
+                        print(f"\n📝 Testing with input: {test_input}")
+                        
+                        result = ra.run(**test_input)
+                        
+                        print("✅ SUCCESS!")
+                        print(f"📤 Result type: {type(result)}")
+                        print(f"📤 Result content:")
+                        if isinstance(result, dict):
+                            print(json.dumps(result, indent=2))
+                        else:
+                            print(result)
+                        
+                        return True  # Success, exit
+                        
+                    except Exception as input_error:
+                        print(f"❌ Input failed: {input_error}")
+                        continue
+                
+            except Exception as tag_error:
+                print(f"❌ Tag '{tag}' failed: {tag_error}")
+                continue
+        
+        print("\n❌ All attempts failed")
+        return False
+        
+    except Exception as e:
+        print(f"❌ General error: {e}")
+        return False
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1:
+        agent_id = sys.argv[1]
+    else:
+        agent_id = input("Enter Agent ID: ").strip()
+    
+    if len(sys.argv) > 2:
+        port = int(sys.argv[2])
+    else:
+        port = 8450
+    
+    test_agent(agent_id, port)
\ No newline at end of file
diff --git a/runagent/cli/commands.py b/runagent/cli/commands.py
index f51d2c1..b2291f4 100644
--- a/runagent/cli/commands.py
+++ b/runagent/cli/commands.py
@@ -1134,7 +1134,7 @@ def status(cleanup_days, agent_id, capacity):
                 table = Table(title="Agents by Deployment Age")
                 table.add_column("#", style="dim", width=3)
                 table.add_column("Status", width=6)
-                table.add_column("Agent ID", style="magenta", width=20)
+                table.add_column("Agent ID", style="magenta", width=36)
                 table.add_column("Framework", style="green", width=12)
                 table.add_column("Deployed At", style="cyan", width=20)
                 table.add_column("Age Note", style="yellow", width=10)
@@ -1154,7 +1154,7 @@ def status(cleanup_days, agent_id, capacity):
                     table.add_row(
                         str(i+1),
                         status_icon,
-                        agent['agent_id'][:18] + "...",
+                        agent['agent_id'],
                         agent['framework'],
                         agent['deployed_at'] or "Unknown",
                         age_label
@@ -1249,7 +1249,7 @@ def status(cleanup_days, agent_id, capacity):
             table = Table(title=f"Local Agents ({len(agents)} total)")
             table.add_column("Status", width=8)
             table.add_column("Files", width=6)
-            table.add_column("Agent ID", style="magenta", width=20)
+            table.add_column("Agent ID", style="magenta", width=36)
             table.add_column("Framework", style="green", width=12)
             table.add_column("Host:Port", style="blue", width=15)
             table.add_column("Runs", style="cyan", width=6)
@@ -1266,7 +1266,7 @@ def status(cleanup_days, agent_id, capacity):
                 table.add_row(
                     status_icon,
                     exists_icon,
-                    agent['agent_id'][:18] + "...",
+                    agent['agent_id'],
                     agent['framework'],
                     f"{agent.get('host', 'N/A')}:{agent.get('port', 'N/A')}",
                     str(agent.get('run_count', 0)),
@@ -1742,7 +1742,7 @@ def logs(agent_id, limit, output_format):
             console.print(f"\n📊 [bold]Agent Log Summary[/bold]")
             
             table = Table(title="Log Counts by Agent")
-            table.add_column("Agent ID", style="magenta", width=20)
+            table.add_column("Agent ID", style="magenta", width=36)
             table.add_column("Framework", style="green", width=12)
             table.add_column("Total Logs", style="cyan", width=10)
             table.add_column("Errors", style="red", width=8)
@@ -1762,7 +1762,7 @@ def logs(agent_id, limit, output_format):
                         last_log_time = "Recent"
                 
                 table.add_row(
-                    agent['agent_id'][:18] + "...",
+                    agent['agent_id'],
                     agent['framework'],
                     str(len(agent_logs)),
                     str(len(error_logs)),
diff --git a/runagent/sdk/db.py b/runagent/sdk/db.py
index 8197321..2337310 100644
--- a/runagent/sdk/db.py
+++ b/runagent/sdk/db.py
@@ -822,6 +822,10 @@ def add_agent(
         framework: str = None,
         status: str = "deployed",
     ) -> Dict:
+        if hasattr(framework, 'value'):
+            framework = framework.value
+        elif framework is not None:
+            framework = str(framework)
         """
         Add a new agent with smart limit enforcement
 
@@ -1533,6 +1537,10 @@ def add_agent_with_auto_port(
         preferred_host: str = "127.0.0.1",
         preferred_port: int = None,
     ) -> Dict:
+        if hasattr(framework, 'value'):
+            framework = framework.value
+        elif framework is not None:
+            framework = str(framework)
         """
         Add a new agent with automatic port allocation
 
diff --git a/runagent/sdk/server/local_server.py b/runagent/sdk/server/local_server.py
index 24ee854..83f21af 100644
--- a/runagent/sdk/server/local_server.py
+++ b/runagent/sdk/server/local_server.py
@@ -537,7 +537,7 @@ def from_path(
             result = db_service.add_agent_with_auto_port(
                 agent_id=agent_id,
                 agent_path=str(agent_path),
-                framework=framework,
+                framework=framework.value if hasattr(framework, 'value') else str(framework),
                 status="ready",
                 preferred_host=host,
                 preferred_port=port,  # Will auto-allocate if None or unavailable
diff --git a/test_scripts/python/client_test_llamaindex.py b/test_scripts/python/client_test_llamaindex.py
index 406c733..d9d77e1 100644
--- a/test_scripts/python/client_test_llamaindex.py
+++ b/test_scripts/python/client_test_llamaindex.py
@@ -17,17 +17,12 @@
 from runagent import RunAgentClient
 
 ra = RunAgentClient(
-    agent_id="408db172-a58b-41f3-b396-0e182784749d",
-    entrypoint_tag="math_stream",
+    agent_id="c843839d-4597-405f-9c5a-c532364edce4",
+    entrypoint_tag="main_stream",
     local=True
     )
 
 for chunk in ra.run(
     "What is 2 * 3?"
 ):
-    if chunk["tool_calls"]:
-        tool_call = chunk['tool_calls']
-        print(f"[TOOL CALL] {tool_call['tool_name']} - {tool_call['tool_kwargs']} ")
-    elif chunk["delta_content"]:
-        print(chunk["delta_content"], end="")
-        
+    print(chunk)