initial commit

.gitignore

@@ -0,0 +1,52 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Environment variables
+.env
+
+# Gradio
+gradio_cached_examples/
+flagged/
+
+# Development files
+private/
+.claude/
+.pytest_cache/

OFPBadWord

@@ -0,0 +1 @@
+Subproject commit 90f2d18964851953163fa88bac5b749b665f6949

README.md

@@ -1,14 +1,345 @@
----
-title: Talker
-emoji: 📚
-colorFrom: gray
-colorTo: red
-sdk: gradio
-sdk_version: 6.5.1
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: Talkative OFP compliant agent
+# 💬 Talker - OFP Chat Agent
+
+An AI-powered conversational agent that implements the [Open Floor Protocol (OFP)](https://openfloor.dev) for interoperable multi-agent conversations. Built with Gradio ChatInterface and supports multiple LLM providers including Qwen, OpenAI, and Ollama.
+
+## ✨ Features
+
+- **🤖 Multi-LLM Support**: Works with HuggingFace (Qwen), OpenAI, or local Ollama models
+- **💬 Clean Chat Interface**: Modern Gradio ChatInterface for seamless conversations
+- **🔌 OFP Protocol**: Full implementation of Open Floor Protocol v1.0.0
+- **🔍 Debug Panel**: Real-time status monitoring and activity logs
+- **⚙️ Configurable**: Easy YAML configuration for all settings
+- **📡 API Endpoints**: RESTful endpoints for OFP integration
+
+## 🏗️ Architecture
+
+```
+┌─────────────────────────────────────┐
+│     Gradio Chat Interface           │
+│   (User chat + OFP debugging)       │
+└─────────────┬───────────────────────┘
+              │
+              ▼
+┌─────────────────────────────────────┐
+│         FastAPI Backend             │
+│  ┌──────────────────────────────┐   │
+│  │  /ofp - OFP Envelope Handler │   │ ← Receives OFP envelopes
+│  │  /manifest - Agent Manifest  │   │
+│  └──────────────┬───────────────┘   │
+│                 │                    │
+│                 ▼                    │
+│  ┌──────────────────────────────┐   │
+│  │  Chat Agent                  │   │
+│  │  - Process OFP envelopes     │   │
+│  │  - Manage conversation       │   │
+│  └──────────────┬───────────────┘   │
+│                 │                    │
+│                 ▼                    │
+│  ┌──────────────────────────────┐   │
+│  │  LLM Client                  │   │
+│  │  - Qwen / OpenAI / Ollama    │   │
+│  │  - Generate responses        │   │
+│  └──────────────────────────────┘   │
+└─────────────────────────────────────┘
+```
+
+## 📋 Requirements
+
+- Python 3.8+
+- pip package manager
+
+## 🚀 Quick Start
+
+### 1. Clone and Setup
+
+```bash
+# Clone the repository
+git clone https://huggingface.co/spaces/BladeSzaSza/Talker
+cd Talker
+
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+### 2. Configuration
+
+Edit `config/config.yaml` to configure your LLM:
+
+```yaml
+llm:
+  provider: 'huggingface'  # or 'openai', 'ollama'
+  model: 'Qwen/Qwen2.5-7B-Instruct'
+  system_prompt: |
+    You are Talker, a helpful AI assistant...
+```
+
+### 3. Set API Keys (if needed)
+
+```bash
+# For HuggingFace
+export HF_TOKEN="your_huggingface_token"
+
+# For OpenAI
+export OPENAI_API_KEY="your_openai_key"
+
+# Ollama runs locally, no key needed
+```
+
+### 4. Run
+
+```bash
+# Standard launch
+python app.py
+
+# With public share URL
+python app.py --share
+
+# Custom port
+python app.py --port 8080
+```
+
+Access the interface at: `http://localhost:7860`
+
+## 🎯 Usage
+
+### Chat Interface
+
+1. Open the **💬 Chat** tab
+2. Type your message and press Enter
+3. The AI responds using your configured LLM
+4. Conversation history is maintained automatically
+
+### OFP Integration
+
+The agent exposes two OFP-compliant endpoints:
+
+**Manifest Endpoint:**
+```bash
+curl http://localhost:7860/manifest
+```
+
+**OFP Envelope Endpoint:**
+```bash
+curl -X POST http://localhost:7860/ofp \
+  -H "Content-Type: application/json" \
+  -d '{
+    "openFloor": {
+      "schema": {"version": "1.0.0"},
+      "conversation": {"id": "conv:test"},
+      "sender": {"speakerUri": "tag:test,2025:user"},
+      "events": [{
+        "eventType": "utterance",
+        "parameters": {
+          "dialogEvent": {
+            "id": "de:test",
+            "speakerUri": "tag:test,2025:user",
+            "span": {"startTime": "2025-01-01T00:00:00Z"},
+            "features": {
+              "text": {
+                "mimeType": "text/plain",
+                "tokens": [{"value": "Hello!"}]
+              }
+            }
+          }
+        }
+      }]
+    }
+  }'
+```
+
+### Debug Panel
+
+The **🔍 Status & Debug** tab shows:
+- Agent status and statistics
+- Recent activity logs
+- Conversation history length
+- OFP message processing
+
+## ⚙️ Configuration
+
+### LLM Providers
+
+#### HuggingFace (Default)
+
+```yaml
+llm:
+  provider: 'huggingface'
+  model: 'Qwen/Qwen2.5-7B-Instruct'
+  max_tokens: 512
+  temperature: 0.7
+```
+
+Requires `HF_TOKEN` environment variable for private models.
+
+#### OpenAI
+
+```yaml
+llm:
+  provider: 'openai'
+  model: 'gpt-4'
+  api_key: 'your-api-key'  # or use OPENAI_API_KEY env var
+```
+
+#### Ollama (Local)
+
+```yaml
+llm:
+  provider: 'ollama'
+  model: 'qwen2.5:7b'
+  api_url: 'http://localhost:11434/api/generate'
+```
+
+Install Ollama from https://ollama.ai and run:
+```bash
+ollama pull qwen2.5:7b
+ollama serve
+```
+
+### Agent Configuration
+
+```yaml
+agent:
+  speaker_uri: 'tag:talker.service,2025:agent-01'
+  service_url: 'https://your-url.com/ofp'
+  convener_uri: 'tag:convener.service,2025:default'
+  convener_url: 'https://convener-url.com/ofp'
+```
+
+### UI Settings
+
+```yaml
+ui:
+  title: '💬 Talker - OFP Chat Agent'
+  description: 'AI-powered conversational agent...'
+  theme: 'soft'  # default, soft, glass, monochrome
+  show_debug_panel: true
+  show_settings: true
+```
+
+## 📁 Project Structure
+
+```
+Talker/
+├── app.py                    # Main Gradio + FastAPI application
+├── requirements.txt          # Python dependencies
+├── config/
+│   └── config.yaml          # Configuration file
+├── src/
+│   ├── __init__.py
+│   ├── models.py            # OFP data structures
+│   ├── ofp_client.py        # OFP envelope handling
+│   ├── llm_client.py        # LLM integration
+│   └── chat_agent.py        # Main agent logic
+└── README.md                # This file
+```
+
+## 🌐 Deployment
+
+### HuggingFace Spaces
+
+1. Push to HuggingFace Spaces repository
+2. Set `HF_TOKEN` secret in Space settings (if using HF models)
+3. Space will auto-deploy with public URL
+
+### Local Network
+
+```bash
+python app.py --share
+```
+
+Generates a temporary public URL for testing with OFP Playground.
+
+### Production Server
+
+```bash
+# Using uvicorn directly
+uvicorn app:app --host 0.0.0.0 --port 7860
+
+# With Gunicorn
+gunicorn app:app -w 4 -k uvicorn.workers.UvicornWorker
+```
+
+## 🔧 Development
+
+### Adding Custom LLM Provider
+
+1. Extend `LLMClient` in `src/llm_client.py`:
+
+```python
+def _generate_custom(self, message, history, max_tokens, temperature):
+    """Generate response using custom API"""
+    # Your implementation here
+    pass
+```
+
+2. Update `generate_response()` to call your method
+
+### Modifying OFP Behavior
+
+Edit `src/chat_agent.py`:
+- `process_envelope()`: Handle incoming OFP events
+- `_handle_utterance()`: Process text messages
+- `send_message()`: Send OFP responses
+
+## 🧪 Testing
+
+Test the chat interface:
+```bash
+python app.py
+# Open browser to http://localhost:7860
+```
+
+Test OFP endpoints:
+```bash
+# Test manifest
+curl http://localhost:7860/manifest
+
+# Test message processing
+curl -X POST http://localhost:7860/ofp \
+  -H "Content-Type: application/json" \
+  -d @test_envelope.json
+```
+
+## 📚 OFP Protocol
+
+This agent implements:
+- **Dialog Event Object v1.0.2**: Text-based conversation messages
+- **Inter-agent Message v1.0.0**: Envelope structure for communication
+- **Assistant Manifest v1.0.0**: Agent identification and capabilities
+
+Supported OFP events:
+- `utterance`: Text messages (main interaction)
+- `getManifests`: Capability discovery
+- `floorRequest`: Request speaking permission (future)
+
+## 🤝 Contributing
+
+Contributions welcome! Areas for improvement:
+- Additional LLM providers
+- Voice/audio support
+- Multi-modal capabilities
+- Enhanced OFP features
+- UI improvements
+
+## 📄 License
+
+Apache 2.0 - See LICENSE file for details
+
+## 🔗 Links
+
+- [Open Floor Protocol](https://openfloor.dev)
+- [OFP Specifications](https://github.com/open-voice-interoperability/openfloor-docs)
+- [Gradio Documentation](https://gradio.app/docs)
+- [Qwen Models](https://huggingface.co/Qwen)
+
+## 💡 Credits
+
+Based on the OFP architecture patterns from [OFPBadWord](https://huggingface.co/spaces/BladeSzaSza/OFPBadWord) sentinel agent.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**Questions or issues?** Open an issue on the repository or check the [OFP documentation](https://openfloor.dev).

app.py

@@ -0,0 +1,422 @@
+"""
+Talker - OFP Chat Agent with AI Integration
+Gradio ChatInterface with OFP protocol support
+"""
+
+import gradio as gr
+import os
+import logging
+import yaml
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+import uvicorn
+from datetime import datetime, timezone
+import uuid
+import json
+
+# Import agent components
+from src.llm_client import LLMClient
+from src.chat_agent import ChatAgent
+from src.models import Envelope
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Load configuration
+CONFIG_FILE = 'config/config.yaml'
+try:
+    with open(CONFIG_FILE, 'r') as f:
+        config = yaml.safe_load(f)
+    logger.info("Configuration loaded successfully")
+except FileNotFoundError:
+    logger.warning("Config file not found, using defaults")
+    config = {
+        'agent': {
+            'speaker_uri': 'tag:talker.service,2025:agent-01',
+            'service_url': 'https://talker-service.com/ofp',
+            'convener_uri': 'tag:convener.service,2025:default',
+            'convener_url': 'https://convener-service.com/ofp'
+        },
+        'llm': {
+            'provider': 'huggingface',
+            'model': 'Qwen/Qwen2.5-7B-Instruct',
+            'max_tokens': 512,
+            'temperature': 0.7,
+            'system_prompt': 'You are a helpful AI assistant participating in an Open Floor Protocol conversation.'
+        },
+        'conversation': {
+            'auto_respond': True,
+            'max_history': 20
+        },
+        'ui': {
+            'title': '💬 Talker - OFP Chat Agent',
+            'description': 'AI-powered conversational agent with Open Floor Protocol support',
+            'theme': 'soft',
+            'show_debug_panel': True,
+            'show_settings': True
+        }
+    }
+
+# Initialize LLM client
+llm_client = LLMClient(
+    provider=config['llm'].get('provider', 'huggingface'),
+    model=config['llm'].get('model', 'Qwen/Qwen2.5-7B-Instruct'),
+    api_key=config['llm'].get('api_key'),
+    api_url=config['llm'].get('api_url'),
+    system_prompt=config['llm'].get('system_prompt')
+)
+
+# Initialize Chat Agent
+agent = ChatAgent(
+    speaker_uri=config['agent']['speaker_uri'],
+    service_url=config['agent']['service_url'],
+    llm_client=llm_client,
+    convener_uri=config['agent'].get('convener_uri'),
+    convener_url=config['agent'].get('convener_url')
+)
+
+# Create FastAPI app
+app = FastAPI()
+
+@app.get("/manifest")
+async def get_manifest():
+    """Serve the assistant manifest"""
+    manifest = agent.get_manifest()
+    return JSONResponse(content=manifest)
+
+@app.post("/ofp")
+async def receive_ofp_envelope(envelope: dict):
+    """
+    Receive OFP envelopes from convener
+    
+    Handles:
+    - getManifests: Returns publishManifest event
+    - utterance: Processes and responds to messages
+    """
+    try:
+        if "openFloor" not in envelope:
+            return JSONResponse(
+                content={"status": "error", "message": "Invalid OFP envelope"},
+                status_code=400
+            )
+
+        openfloor_data = envelope["openFloor"]
+        events = openfloor_data.get("events", [])
+
+        # Process each event
+        for event in events:
+            event_type = event.get("eventType")
+
+            # Handle getManifests event
+            if event_type == "getManifests":
+                manifest = agent.get_manifest()
+                return JSONResponse(content={
+                    "openFloor": {
+                        "schema": {"version": "1.0.0"},
+                        "conversation": openfloor_data.get("conversation", {}),
+                        "sender": {
+                            "speakerUri": config['agent']['speaker_uri'],
+                            "serviceUrl": config['agent']['service_url']
+                        },
+                        "events": [{
+                            "eventType": "publishManifest",
+                            "to": event.get("to", {}),
+                            "parameters": {
+                                "servicingManifests": [manifest]
+                            }
+                        }]
+                    }
+                })
+
+            # Handle utterance events
+            elif event_type == "utterance":
+                # Process envelope through agent
+                ofp_envelope = Envelope.from_dict(envelope)
+                response_text = agent.process_envelope(ofp_envelope)
+
+                if response_text and config['conversation'].get('auto_respond', True):
+                    # Send response back
+                    return JSONResponse(content={
+                        "openFloor": {
+                            "schema": {"version": "1.0.0"},
+                            "conversation": openfloor_data.get("conversation", {}),
+                            "sender": {
+                                "speakerUri": config['agent']['speaker_uri'],
+                                "serviceUrl": config['agent']['service_url']
+                            },
+                            "events": [{
+                                "eventType": "utterance",
+                                "to": event.get("to", {}),
+                                "parameters": {
+                                    "dialogEvent": {
+                                        "id": f"de:{uuid.uuid4()}",
+                                        "speakerUri": config['agent']['speaker_uri'],
+                                        "span": {
+                                            "startTime": datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z')
+                                        },
+                                        "features": {
+                                            "text": {
+                                                "mimeType": "text/plain",
+                                                "tokens": [{
+                                                    "value": response_text,
+                                                    "confidence": 1
+                                                }]
+                                            }
+                                        }
+                                    }
+                                }
+                            }]
+                        }
+                    })
+
+        # Acknowledge other events
+        return JSONResponse(content={
+            "openFloor": {
+                "schema": {"version": "1.0.0"},
+                "conversation": openfloor_data.get("conversation", {}),
+                "sender": {
+                    "speakerUri": config['agent']['speaker_uri'],
+                    "serviceUrl": config['agent']['service_url']
+                },
+                "events": []
+            }
+        })
+
+    except Exception as e:
+        logger.error(f"Error processing OFP envelope: {e}")
+        return JSONResponse(
+            content={"status": "error", "message": str(e)},
+            status_code=400
+        )
+
+
+# Gradio ChatInterface Functions
+def chat_response(message, history):
+    """Generate response for Gradio ChatInterface"""
+    try:
+        # Add to conversation history
+        agent.conversation_history.append({
+            "role": "user",
+            "content": message
+        })
+
+        # Generate response
+        response = llm_client.generate_response(
+            message=message,
+            conversation_history=agent.conversation_history[:-1],
+            max_tokens=config['llm'].get('max_tokens', 512),
+            temperature=config['llm'].get('temperature', 0.7)
+        )
+
+        # Add response to history
+        agent.conversation_history.append({
+            "role": "assistant",
+            "content": response
+        })
+
+        # Keep history within limits
+        max_history = config['conversation'].get('max_history', 20)
+        if len(agent.conversation_history) > max_history * 2:
+            agent.conversation_history = agent.conversation_history[-(max_history * 2):]
+
+        return response
+
+    except Exception as e:
+        logger.error(f"Error generating chat response: {e}")
+        return f"Sorry, I encountered an error: {str(e)}"
+
+
+def get_status_info():
+    """Get current agent status for display"""
+    status = agent.get_status()
+    return f"""
+**Agent Status:**
+- Speaker URI: `{status['speaker_uri']}`
+- Messages Processed: {status['messages_processed']}
+- Responses Sent: {status['responses_sent']}
+- History Length: {status['history_length']}
+- Conversation ID: `{status.get('conversation_id', 'N/A')}`
+"""
+
+
+def get_recent_logs():
+    """Get recent activity logs"""
+    status = agent.get_status()
+    logs = status.get('recent_logs', [])
+    return "\n".join(logs) if logs else "No recent activity"
+
+
+def clear_conversation():
+    """Clear conversation history"""
+    agent.clear_history()
+    return "Conversation history cleared!"
+
+
+def get_ofp_envelope_info():
+    """Show OFP endpoint information"""
+    return f"""
+### OFP Endpoints
+
+**Manifest URL:** `{config['agent']['service_url'].replace('/ofp', '/manifest')}`
+
+**OFP Endpoint:** `{config['agent']['service_url']}`
+
+**Test with curl:**
+```bash
+curl -X POST {config['agent']['service_url']} \\
+  -H "Content-Type: application/json" \\
+  -d '{{
+    "openFloor": {{
+      "schema": {{"version": "1.0.0"}},
+      "conversation": {{"id": "conv:test"}},
+      "sender": {{"speakerUri": "tag:test,2025:user"}},
+      "events": [{{
+        "eventType": "utterance",
+        "parameters": {{
+          "dialogEvent": {{
+            "id": "de:test",
+            "speakerUri": "tag:test,2025:user",
+            "span": {{"startTime": "2025-01-01T00:00:00Z"}},
+            "features": {{
+              "text": {{
+                "mimeType": "text/plain",
+                "tokens": [{{"value": "Hello!"}}]
+              }}
+            }}
+          }}
+        }}
+      }}]
+    }}
+  }}'
+```
+"""
+
+
+# Build Gradio Interface
+custom_css = """
+.gradio-container {
+    font-family: 'Inter', system-ui, sans-serif !important;
+    max-width: 1400px !important;
+}
+.chat-message {
+    padding: 1rem !important;
+}
+"""
+
+with gr.Blocks(
+    title=config['ui'].get('title', 'Talker - OFP Chat Agent'),
+    theme=config['ui'].get('theme', 'soft'),
+    css=custom_css
+) as demo:
+    
+    gr.Markdown(f"""
+    # {config['ui'].get('title', '💬 Talker - OFP Chat Agent')}
+    {config['ui'].get('description', 'AI-powered conversational agent with Open Floor Protocol support')}
+    
+    **Model:** {config['llm']['model']} | **Provider:** {config['llm']['provider']}
+    """)
+
+    with gr.Tab("💬 Chat"):
+        chatbot = gr.ChatInterface(
+            fn=chat_response,
+            title="",
+            description="Chat with the AI assistant",
+            examples=[
+                "Hello! How are you?",
+                "What is the Open Floor Protocol?",
+                "Can you explain what you do?",
+                "Tell me a joke!"
+            ],
+            retry_btn=None,
+            undo_btn=None,
+            clear_btn="🗑️ Clear Chat"
+        )
+
+    if config['ui'].get('show_debug_panel', True):
+        with gr.Tab("🔍 Status & Debug"):
+            with gr.Row():
+                with gr.Column():
+                    status_display = gr.Markdown(get_status_info())
+                    refresh_status_btn = gr.Button("🔄 Refresh Status")
+                    refresh_status_btn.click(
+                        fn=get_status_info,
+                        outputs=status_display
+                    )
+                
+                with gr.Column():
+                    logs_display = gr.Textbox(
+                        label="Activity Logs",
+                        value=get_recent_logs(),
+                        lines=10,
+                        max_lines=20
+                    )
+                    refresh_logs_btn = gr.Button("🔄 Refresh Logs")
+                    refresh_logs_btn.click(
+                        fn=get_recent_logs,
+                        outputs=logs_display
+                    )
+
+            clear_history_btn = gr.Button("🗑️ Clear Conversation History")
+            clear_result = gr.Textbox(label="Result", interactive=False)
+            clear_history_btn.click(
+                fn=clear_conversation,
+                outputs=clear_result
+            )
+
+    if config['ui'].get('show_settings', True):
+        with gr.Tab("⚙️ OFP Configuration"):
+            ofp_info = gr.Markdown(get_ofp_envelope_info())
+            
+            gr.Markdown("""
+            ### Configuration
+            Edit `config/config.yaml` to change:
+            - LLM provider and model
+            - System prompt
+            - Generation parameters
+            - OFP endpoints
+            
+            ### Environment Variables
+            - `HF_TOKEN`: HuggingFace API token (for private models)
+            - `OPENAI_API_KEY`: OpenAI API key (if using OpenAI)
+            """)
+
+    gr.Markdown("""
+    ---
+    **About:** This agent implements the [Open Floor Protocol](https://openfloor.dev) for interoperable AI conversations.
+    
+    **OFP v1.0.0** | Built with [Gradio](https://gradio.app) | Powered by {model}
+    """.format(model=config['llm']['model']))
+
+
+# Launch configuration
+if __name__ == "__main__":
+    import argparse
+
+    is_hf_space = os.getenv("SPACE_ID") is not None
+
+    parser = argparse.ArgumentParser(description='Talker - OFP Chat Agent')
+    parser.add_argument('--share', action='store_true', help='Create public share link')
+    parser.add_argument('--port', type=int, default=7860, help='Port to run on')
+    args = parser.parse_args()
+
+    print("\n" + "="*60)
+    print("💬 Talker - OFP Chat Agent")
+    print("="*60)
+    print(f"\nModel: {config['llm']['model']}")
+    print(f"Provider: {config['llm']['provider']}")
+    print(f"Speaker URI: {config['agent']['speaker_uri']}")
+    print("="*60 + "\n")
+
+    # Mount Gradio app to FastAPI
+    app_with_gradio = gr.mount_gradio_app(app, demo, path="/")
+
+    uvicorn.run(
+        app_with_gradio,
+        host="0.0.0.0",
+        port=args.port,
+        log_level="info"
+    )

config/config.yaml

@@ -0,0 +1,73 @@
+# Talker - OFP Chat Agent Configuration
+
+agent:
+  # Agent identification
+  speaker_uri: 'tag:talker.service,2025:agent-01'
+  service_url: 'https://bladeszasza-talker.hf.space/ofp'
+
+  # Convener endpoints (optional - for sending messages)
+  convener_uri: 'tag:convener.service,2025:default'
+  convener_url: 'https://convener-service.com/ofp'
+
+llm:
+  # LLM provider: huggingface, openai, ollama
+  provider: 'huggingface'
+  
+  # Model name
+  model: 'Qwen/Qwen2.5-7B-Instruct'
+  
+  # API configuration
+  # For HuggingFace: set HF_TOKEN environment variable
+  # For OpenAI: set OPENAI_API_KEY environment variable
+  # For Ollama: runs locally, no key needed
+  api_url: null  # Optional: custom API endpoint
+  
+  # Generation parameters
+  max_tokens: 512
+  temperature: 0.7
+  
+  # System prompt
+  system_prompt: |
+    You are Talker, a helpful AI assistant participating in an Open Floor Protocol conversation.
+    You provide clear, concise, and friendly responses.
+    You can discuss a wide range of topics and help with questions.
+
+conversation:
+  # Automatically respond to all messages
+  auto_respond: true
+  
+  # Maximum conversation history length
+  max_history: 20
+  
+  # Clear history after inactivity (minutes)
+  clear_after_minutes: 30
+
+ui:
+  # Chat interface title
+  title: '💬 Talker - OFP Chat Agent'
+  
+  # Chat interface description
+  description: 'AI-powered conversational agent with Open Floor Protocol support'
+  
+  # Theme: default, soft, glass, monochrome
+  theme: 'soft'
+  
+  # Show OFP debugging panel
+  show_debug_panel: true
+  
+  # Show settings panel
+  show_settings: true
+
+# Alternative LLM configurations (uncomment to use)
+
+# OpenAI Configuration:
+# llm:
+#   provider: 'openai'
+#   model: 'gpt-4'
+#   api_key: 'your-api-key'  # or use OPENAI_API_KEY env var
+
+# Ollama Configuration (local):
+# llm:
+#   provider: 'ollama'
+#   model: 'qwen2.5:7b'
+#   api_url: 'http://localhost:11434/api/generate'

requirements.txt

@@ -0,0 +1,5 @@
+gradio==5.9.1
+fastapi>=0.104.0
+uvicorn>=0.24.0
+requests>=2.31.0
+pyyaml>=6.0

src/__init__.py

@@ -0,0 +1,2 @@
+# Talker - OFP Chat Agent with AI Integration
+__version__ = "1.0.0"

src/chat_agent.py

@@ -0,0 +1,237 @@
+"""
+Chat Agent
+OFP-compliant conversational agent with LLM integration
+"""
+
+import logging
+from typing import Dict, List, Optional
+from datetime import datetime, timezone
+import uuid
+
+from .ofp_client import OFPClient
+from .llm_client import LLMClient
+from .models import Envelope, DialogEvent
+
+logger = logging.getLogger(__name__)
+
+
+class ChatAgent:
+    """OFP Chat Agent with AI conversation capabilities"""
+
+    def __init__(
+        self,
+        speaker_uri: str,
+        service_url: str,
+        llm_client: LLMClient,
+        convener_uri: Optional[str] = None,
+        convener_url: Optional[str] = None
+    ):
+        """
+        Initialize chat agent
+
+        Args:
+            speaker_uri: Agent's unique speaker URI
+            service_url: Agent's service endpoint URL
+            llm_client: Configured LLM client instance
+            convener_uri: Convener's speaker URI (optional)
+            convener_url: Convener's service endpoint URL (optional)
+        """
+        self.speaker_uri = speaker_uri
+        self.service_url = service_url
+        self.convener_uri = convener_uri
+        self.convener_url = convener_url
+
+        # Initialize LLM client
+        self.llm_client = llm_client
+
+        # Initialize OFP client
+        manifest = self._create_manifest()
+        self.ofp_client = OFPClient(speaker_uri, service_url, manifest)
+
+        # Conversation state
+        self.conversation_history: List[Dict[str, str]] = []
+        self.current_conversation_id: Optional[str] = None
+        self.messages_processed = 0
+        self.responses_sent = 0
+        self.activity_log = []
+
+        logger.info(f"Chat Agent initialized: {speaker_uri}")
+
+    def _create_manifest(self) -> Dict:
+        """Create assistant manifest for chat agent"""
+        return {
+            "identification": {
+                "speakerUri": self.speaker_uri,
+                "serviceUrl": self.service_url,
+                "conversationalName": "Talker AI Assistant",
+                "role": "Conversational Agent",
+                "synopsis": "AI-powered conversational assistant for Open Floor Protocol"
+            },
+            "capabilities": [{
+                "keyphrases": ["chat", "conversation", "AI assistant", "questions", "help"],
+                "supportedLayers": ["text"],
+                "descriptions": ["Engages in natural conversations and answers questions"]
+            }]
+        }
+
+    def process_envelope(self, envelope: Envelope) -> Optional[str]:
+        """
+        Process incoming OFP envelope
+
+        Args:
+            envelope: OFP envelope to process
+
+        Returns:
+            Response text if generated, None otherwise
+        """
+        try:
+            self.messages_processed += 1
+
+            # Update conversation ID
+            if envelope.conversation.get('id'):
+                self.current_conversation_id = envelope.conversation['id']
+
+            for event in envelope.events:
+                event_type = event.get('eventType')
+
+                # Handle utterance events
+                if event_type == 'utterance':
+                    return self._handle_utterance(envelope, event)
+
+                # Handle getManifests
+                elif event_type == 'getManifests':
+                    self._log_activity("Received getManifests request")
+
+            return None
+
+        except Exception as e:
+            logger.error(f"Error processing envelope: {e}")
+            self._log_activity(f"ERROR: {str(e)}")
+            return None
+
+    def _handle_utterance(self, envelope: Envelope, event: Dict) -> Optional[str]:
+        """
+        Handle utterance event and generate response
+
+        Args:
+            envelope: OFP envelope
+            event: Utterance event
+
+        Returns:
+            Generated response text
+        """
+        try:
+            # Extract text from dialog event
+            params = event.get('parameters', {})
+            dialog_event = params.get('dialogEvent', {})
+            features = dialog_event.get('features', {})
+            text_feature = features.get('text', {})
+            tokens = text_feature.get('tokens', [])
+
+            # Combine tokens into text
+            text = ' '.join(token.get('value', '') for token in tokens)
+
+            if not text:
+                return None
+
+            # Get speaker info
+            speaker_uri = dialog_event.get('speakerUri', 'unknown')
+
+            # Don't respond to own messages
+            if speaker_uri == self.speaker_uri:
+                return None
+
+            self._log_activity(f"Received: {text[:50]}..." if len(text) > 50 else f"Received: {text}")
+
+            # Add to conversation history
+            self.conversation_history.append({
+                "role": "user",
+                "content": text
+            })
+
+            # Generate response using LLM
+            response = self.llm_client.generate_response(
+                message=text,
+                conversation_history=self.conversation_history[:-1]  # Exclude current message
+            )
+
+            # Add response to history
+            self.conversation_history.append({
+                "role": "assistant",
+                "content": response
+            })
+
+            self.responses_sent += 1
+            self._log_activity(f"Sent: {response[:50]}..." if len(response) > 50 else f"Sent: {response}")
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error handling utterance: {e}")
+            return f"Sorry, I encountered an error processing your message."
+
+    def send_message(self, text: str, recipient_url: Optional[str] = None) -> bool:
+        """
+        Send message to the floor
+
+        Args:
+            text: Message text to send
+            recipient_url: Recipient URL (uses convener_url if not specified)
+
+        Returns:
+            True if sent successfully
+        """
+        try:
+            if not self.current_conversation_id:
+                self.current_conversation_id = f"conv:{uuid.uuid4()}"
+
+            url = recipient_url or self.convener_url
+            if not url:
+                logger.error("No recipient URL specified")
+                return False
+
+            success = self.ofp_client.send_utterance(
+                conversation_id=self.current_conversation_id,
+                recipient_url=url,
+                text=text
+            )
+
+            if success:
+                self.responses_sent += 1
+                self._log_activity(f"Sent: {text[:50]}..." if len(text) > 50 else f"Sent: {text}")
+
+            return success
+
+        except Exception as e:
+            logger.error(f"Error sending message: {e}")
+            return False
+
+    def clear_history(self):
+        """Clear conversation history"""
+        self.conversation_history = []
+        self._log_activity("Conversation history cleared")
+
+    def get_status(self) -> Dict:
+        """Get current agent status"""
+        return {
+            "speaker_uri": self.speaker_uri,
+            "conversation_id": self.current_conversation_id,
+            "messages_processed": self.messages_processed,
+            "responses_sent": self.responses_sent,
+            "history_length": len(self.conversation_history),
+            "recent_logs": self.activity_log[-10:] if self.activity_log else []
+        }
+
+    def get_manifest(self) -> Dict:
+        """Get assistant manifest"""
+        return self.ofp_client.get_manifest()
+
+    def _log_activity(self, message: str):
+        """Log activity with timestamp"""
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        log_entry = f"[{timestamp}] {message}"
+        self.activity_log.append(log_entry)
+
+        # Keep only last 100 entries
+        if len(self.activity_log) > 100:
+            self.activity_log = self.activity_log[-100:]

src/llm_client.py

@@ -0,0 +1,219 @@
+"""
+LLM Client
+Handles integration with various language models (Qwen, OpenAI-compatible APIs, etc.)
+"""
+
+import logging
+import requests
+from typing import List, Dict, Optional
+import os
+
+logger = logging.getLogger(__name__)
+
+
+class LLMClient:
+    """Client for interacting with language models"""
+
+    def __init__(
+        self,
+        provider: str = "huggingface",
+        model: str = "Qwen/Qwen2.5-7B-Instruct",
+        api_key: Optional[str] = None,
+        api_url: Optional[str] = None,
+        system_prompt: Optional[str] = None
+    ):
+        """
+        Initialize LLM client
+
+        Args:
+            provider: LLM provider (huggingface, openai, ollama)
+            model: Model name/identifier
+            api_key: API key for authentication
+            api_url: Custom API endpoint URL
+            system_prompt: System instructions for the model
+        """
+        self.provider = provider
+        self.model = model
+        self.api_key = api_key or os.getenv("HF_TOKEN")
+        self.system_prompt = system_prompt or "You are a helpful AI assistant participating in an Open Floor Protocol conversation."
+        
+        # Set API URL based on provider
+        if api_url:
+            self.api_url = api_url
+        elif provider == "huggingface":
+            self.api_url = f"https://api-inference.huggingface.co/models/{model}"
+        elif provider == "openai":
+            self.api_url = "https://api.openai.com/v1/chat/completions"
+        elif provider == "ollama":
+            self.api_url = api_url or "http://localhost:11434/api/generate"
+        else:
+            raise ValueError(f"Unsupported provider: {provider}")
+
+        logger.info(f"LLM Client initialized: {provider} - {model}")
+
+    def generate_response(
+        self,
+        message: str,
+        conversation_history: Optional[List[Dict[str, str]]] = None,
+        max_tokens: int = 512,
+        temperature: float = 0.7
+    ) -> str:
+        """
+        Generate response from LLM
+
+        Args:
+            message: User message to respond to
+            conversation_history: Previous messages in conversation
+            max_tokens: Maximum tokens to generate
+            temperature: Sampling temperature
+
+        Returns:
+            Generated response text
+        """
+        try:
+            if self.provider == "huggingface":
+                return self._generate_huggingface(
+                    message, conversation_history, max_tokens, temperature
+                )
+            elif self.provider == "openai":
+                return self._generate_openai(
+                    message, conversation_history, max_tokens, temperature
+                )
+            elif self.provider == "ollama":
+                return self._generate_ollama(
+                    message, conversation_history, max_tokens, temperature
+                )
+            else:
+                return f"Error: Unsupported provider {self.provider}"
+
+        except Exception as e:
+            logger.error(f"Error generating response: {e}")
+            return f"Sorry, I encountered an error: {str(e)}"
+
+    def _generate_huggingface(
+        self,
+        message: str,
+        conversation_history: Optional[List[Dict[str, str]]],
+        max_tokens: int,
+        temperature: float
+    ) -> str:
+        """Generate response using HuggingFace Inference API"""
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        # Build prompt with conversation history
+        prompt = self._build_prompt(message, conversation_history)
+
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": max_tokens,
+                "temperature": temperature,
+                "return_full_text": False
+            }
+        }
+
+        response = requests.post(
+            self.api_url,
+            headers=headers,
+            json=payload,
+            timeout=60
+        )
+        response.raise_for_status()
+
+        result = response.json()
+        
+        # Handle different response formats
+        if isinstance(result, list) and len(result) > 0:
+            return result[0].get("generated_text", "").strip()
+        elif isinstance(result, dict):
+            return result.get("generated_text", "").strip()
+        else:
+            logger.warning(f"Unexpected response format: {result}")
+            return "I couldn't generate a proper response."
+
+    def _generate_openai(
+        self,
+        message: str,
+        conversation_history: Optional[List[Dict[str, str]]],
+        max_tokens: int,
+        temperature: float
+    ) -> str:
+        """Generate response using OpenAI-compatible API"""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}"
+        }
+
+        messages = [{"role": "system", "content": self.system_prompt}]
+        
+        if conversation_history:
+            messages.extend(conversation_history)
+        
+        messages.append({"role": "user", "content": message})
+
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature
+        }
+
+        response = requests.post(
+            self.api_url,
+            headers=headers,
+            json=payload,
+            timeout=60
+        )
+        response.raise_for_status()
+
+        result = response.json()
+        return result["choices"][0]["message"]["content"].strip()
+
+    def _generate_ollama(
+        self,
+        message: str,
+        conversation_history: Optional[List[Dict[str, str]]],
+        max_tokens: int,
+        temperature: float
+    ) -> str:
+        """Generate response using Ollama local API"""
+        prompt = self._build_prompt(message, conversation_history)
+
+        payload = {
+            "model": self.model,
+            "prompt": prompt,
+            "options": {
+                "num_predict": max_tokens,
+                "temperature": temperature
+            }
+        }
+
+        response = requests.post(
+            self.api_url,
+            json=payload,
+            timeout=60
+        )
+        response.raise_for_status()
+
+        result = response.json()
+        return result.get("response", "").strip()
+
+    def _build_prompt(
+        self,
+        message: str,
+        conversation_history: Optional[List[Dict[str, str]]]
+    ) -> str:
+        """Build prompt with system instruction and conversation history"""
+        parts = [f"System: {self.system_prompt}\n"]
+        
+        if conversation_history:
+            for msg in conversation_history:
+                role = msg.get("role", "user")
+                content = msg.get("content", "")
+                parts.append(f"{role.capitalize()}: {content}\n")
+        
+        parts.append(f"User: {message}\nAssistant:")
+        
+        return "\n".join(parts)

src/models.py

@@ -0,0 +1,154 @@
+"""
+OFP Data Models
+Implements Open Floor Protocol envelope and event structures following v1.0.0 specifications
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Any
+from datetime import datetime, timezone
+import json
+import uuid
+
+
+@dataclass
+class Identification:
+    """Assistant identification information"""
+    speaker_uri: str
+    service_url: str
+    conversational_name: str
+    organization: Optional[str] = None
+    role: Optional[str] = None
+    synopsis: Optional[str] = None
+
+
+@dataclass
+class DialogEvent:
+    """Dialog event following OFP Dialog Event Object v1.0.2"""
+    id: str
+    speaker_uri: str
+    span: Dict[str, str]
+    features: Dict[str, Any]
+
+    @staticmethod
+    def create_text_event(speaker_uri: str, text: str, event_id: Optional[str] = None) -> 'DialogEvent':
+        """Create a text-based dialog event"""
+        return DialogEvent(
+            id=event_id or f"de:{uuid.uuid4()}",
+            speaker_uri=speaker_uri,
+            span={"startTime": datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z')},
+            features={
+                "text": {
+                    "mimeType": "text/plain",
+                    "tokens": [{"value": text}]
+                }
+            }
+        )
+
+    def to_dict(self) -> Dict:
+        """Convert to dictionary for serialization"""
+        return {
+            "id": self.id,
+            "speakerUri": self.speaker_uri,
+            "span": self.span,
+            "features": self.features
+        }
+
+
+@dataclass
+class Event:
+    """OFP Event structure for inter-agent messages"""
+    event_type: str
+    to: Optional[Dict[str, Any]] = None
+    parameters: Optional[Dict[str, Any]] = None
+
+    def to_dict(self) -> Dict:
+        """Convert to dictionary for serialization"""
+        result = {"eventType": self.event_type}
+        if self.to:
+            result["to"] = self.to
+        if self.parameters:
+            result["parameters"] = self.parameters
+        return result
+
+
+@dataclass
+class Envelope:
+    """OFP Envelope following Inter-agent Message v1.0.0"""
+    schema: Dict[str, str]
+    conversation: Dict[str, Any]
+    sender: Dict[str, str]
+    events: List[Dict[str, Any]]
+
+    @staticmethod
+    def from_json(json_str: str) -> 'Envelope':
+        """Parse OFP envelope from JSON string"""
+        data = json.loads(json_str)
+        ofp = data.get('openFloor', {})
+        return Envelope(
+            schema=ofp.get('schema', {}),
+            conversation=ofp.get('conversation', {}),
+            sender=ofp.get('sender', {}),
+            events=ofp.get('events', [])
+        )
+
+    @staticmethod
+    def from_dict(data: Dict) -> 'Envelope':
+        """Parse OFP envelope from dictionary"""
+        ofp = data.get('openFloor', data)  # Support both wrapped and unwrapped
+        return Envelope(
+            schema=ofp.get('schema', {}),
+            conversation=ofp.get('conversation', {}),
+            sender=ofp.get('sender', {}),
+            events=ofp.get('events', [])
+        )
+
+    def to_payload(self) -> Dict:
+        """Convert to JSON payload for transmission"""
+        return {
+            "openFloor": {
+                "schema": self.schema,
+                "conversation": self.conversation,
+                "sender": self.sender,
+                "events": self.events
+            }
+        }
+
+    def to_json(self) -> str:
+        """Convert to JSON string"""
+        return json.dumps(self.to_payload(), indent=2)
+
+
+def validate_envelope(envelope: Envelope) -> bool:
+    """Validate OFP envelope structure"""
+    try:
+        # Check required fields
+        if not envelope.schema or 'version' not in envelope.schema:
+            return False
+
+        if not envelope.conversation or 'id' not in envelope.conversation:
+            return False
+
+        if not envelope.sender or 'speakerUri' not in envelope.sender:
+            return False
+
+        if not isinstance(envelope.events, list):
+            return False
+
+        # Validate each event
+        for event in envelope.events:
+            if not isinstance(event, dict) or 'eventType' not in event:
+                return False
+
+        return True
+    except Exception:
+        return False
+
+
+def create_envelope(conversation_id: str, speaker_uri: str, events: List[Dict]) -> Envelope:
+    """Helper function to create a valid OFP envelope"""
+    return Envelope(
+        schema={"version": "1.0.0"},
+        conversation={"id": conversation_id},
+        sender={"speakerUri": speaker_uri},
+        events=events
+    )

src/ofp_client.py

@@ -0,0 +1,116 @@
+"""
+OFP Client
+Handles sending and receiving Open Floor Protocol envelopes via HTTPS
+"""
+
+import requests
+import logging
+import json
+from typing import Dict, Optional
+from .models import Envelope, DialogEvent
+
+logger = logging.getLogger(__name__)
+
+
+class OFPClient:
+    """Client for sending OFP envelopes to conveners and other assistants"""
+
+    def __init__(self, speaker_uri: str, service_url: str, manifest: Dict):
+        self.speaker_uri = speaker_uri
+        self.service_url = service_url
+        self.manifest = manifest
+        logger.info(f"OFP Client initialized for {speaker_uri}")
+
+    def send_envelope(self, recipient_url: str, envelope: Envelope, timeout: int = 10) -> bool:
+        """Send OFP envelope to recipient via HTTPS POST"""
+        try:
+            payload = envelope.to_payload()
+            logger.debug(f"Sending envelope to {recipient_url}: {json.dumps(payload, indent=2)}")
+
+            response = requests.post(
+                recipient_url,
+                json=payload,
+                headers={
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'OFP-Talker-Agent/1.0'
+                },
+                timeout=timeout
+            )
+            response.raise_for_status()
+
+            logger.info(f"✓ Envelope sent successfully to {recipient_url}")
+            return True
+
+        except requests.exceptions.Timeout:
+            logger.error(f"✗ Timeout sending envelope to {recipient_url}")
+            return False
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"✗ Failed to send envelope to {recipient_url}: {e}")
+            return False
+
+        except Exception as e:
+            logger.error(f"✗ Unexpected error sending envelope: {e}")
+            return False
+
+    def send_utterance(
+        self,
+        conversation_id: str,
+        recipient_url: str,
+        text: str,
+        to: Optional[Dict] = None
+    ) -> bool:
+        """Send utterance message to the floor"""
+        try:
+            dialog_event = DialogEvent.create_text_event(
+                speaker_uri=self.speaker_uri,
+                text=text
+            )
+
+            event = {
+                "eventType": "utterance",
+                "parameters": {
+                    "dialogEvent": dialog_event.to_dict()
+                }
+            }
+
+            if to:
+                event["to"] = to
+
+            envelope = Envelope(
+                schema={"version": "1.0.0"},
+                conversation={"id": conversation_id},
+                sender={"speakerUri": self.speaker_uri},
+                events=[event]
+            )
+
+            return self.send_envelope(recipient_url, envelope)
+
+        except Exception as e:
+            logger.error(f"Error sending utterance: {e}")
+            return False
+
+    def request_floor(
+        self,
+        conversation_id: str,
+        convener_url: str,
+        convener_uri: str
+    ) -> bool:
+        """Request speaking floor from convener"""
+        envelope = Envelope(
+            schema={"version": "1.0.0"},
+            conversation={"id": conversation_id},
+            sender={"speakerUri": self.speaker_uri},
+            events=[{
+                "eventType": "floorRequest",
+                "to": {
+                    "speakerUri": convener_uri
+                }
+            }]
+        )
+
+        return self.send_envelope(convener_url, envelope)
+
+    def get_manifest(self) -> Dict:
+        """Return assistant manifest"""
+        return self.manifest