cota 1.0.1__py3-none-any.whl

cota/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.1"  # same as pyproject.toml

cota/__main__.py

@@ -0,0 +1,284 @@
+# encoding:utf-8
+import argparse
+import os
+import shutil
+import sys
+import logging
+import ssl
+from typing import Text, Optional, Dict, Any
+from sanic import Sanic
+import asyncio
+from cota import server
+from cota.task import Task
+from cota.agent import Agent
+from cota.channels import channel, socketio, websocket, cmdline, sse
+from cota.utils.common import list_routes
+from cota import __version__
+
+logger = logging.getLogger(__name__)
+
+def validate_ssl_files(cert_path: str, key_path: str) -> bool:
+    """Validate SSL certificate and key files"""
+    try:
+        if not os.path.exists(cert_path):
+            raise FileNotFoundError(f"SSL certificate file not found: {cert_path}")
+        if not os.path.exists(key_path):
+            raise FileNotFoundError(f"SSL key file not found: {key_path}")
+            
+        context = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
+        context.load_cert_chain(cert_path, keyfile=key_path)
+        return True
+    except (FileNotFoundError, ssl.SSLError) as e:
+        raise ValueError(f"Invalid SSL configuration: {str(e)}")
+
+def create_server_config(args):
+    """Create server configuration including SSL settings"""
+    server_config = {
+        'host': args.host,
+        'port': args.port,
+        'debug': args.debug
+    }
+    
+    if args.ssl_cert and args.ssl_key:
+        # Validate SSL files before creating config
+        if validate_ssl_files(args.ssl_cert, args.ssl_key):
+            server_config['ssl'] = {
+                'cert': args.ssl_cert,
+                'key': args.ssl_key
+            }
+    
+    return server_config
+
+def run(args):
+    agent = Agent.load_from_path(path=args.config)
+    app = server.create_app(agent)
+
+    # Define channel configurations
+    channel_configs = {
+        'socket.io': {
+            'class': socketio.SocketIO,
+            'kwargs': {},
+            'register_kwargs': {'route': '/webhooks/'}
+        },
+        'websocket': {
+            'class': websocket.Websocket,
+            'kwargs': {
+                'connection_timeout': 1000,
+                'room_timeout': 3600
+            },
+            'register_kwargs': {}
+        },
+        'sse': {
+            'class': sse.SSE,
+            'kwargs': {
+                'connection_timeout': 1000,
+                'room_timeout': 3600
+            },
+            'register_kwargs': {}
+        }
+    }
+
+    # Initialize and register channel
+    if args.channel not in channel_configs:
+        raise ValueError(f"Unsupported channel: {args.channel}. "
+                        f"Available channels: {list(channel_configs.keys())}")
+    
+    config = channel_configs[args.channel]
+    channel_class = config['class']
+    
+    try:
+        input_channels = channel_class(**config['kwargs'])
+        channel.register([input_channels], app, **config['register_kwargs'])
+        
+        # Configure logging for the channel
+        logger = logging.getLogger(f"cota.channels.{args.channel}")
+        logger.info(f"Initialized {args.channel} channel")
+        
+        list_routes(app)
+        
+        # Run server with configuration
+        server_config = create_server_config(args)
+        app.run(**server_config)
+        
+    except Exception as e:
+        logger.error(f"Failed to initialize {args.channel} channel: {e}")
+        raise
+
+
+async def shell(args):
+    agent = Agent.load_from_path(path=args.config)
+    print("Agent loaded. Type a message and press enter.")
+
+    async def handler(message, channel):
+        await agent.processor.handle_message(message, channel)
+    
+    cmdline_channel = cmdline.Cmdline(on_new_message=handler)
+    await cmdline_channel.on_connect()
+
+async def task(args):
+    task = Task.load_from_path(path=args.config)
+    print("Task loaded.")
+    await task.run()
+
+def init(args):
+    # Define the directory and files to be created
+    project_dir = "cota_projects"
+    template_dir = "bots"  # Replace with the actual directory name
+
+    # Create the project directory
+    if not os.path.exists(project_dir):
+        os.makedirs(project_dir)
+        print(f"Created directory: {project_dir}")
+    else:
+        print(f"Directory {project_dir} already exists.")
+
+    # Copy the contents of the template directory
+    src_dir = os.path.join(os.path.dirname(__file__), template_dir)
+    if os.path.exists(src_dir):
+        for item in os.listdir(src_dir):
+            src_item = os.path.join(src_dir, item)
+            dst_item = os.path.join(project_dir, item)
+            if os.path.isdir(src_item):
+                shutil.copytree(src_item, dst_item)
+            else:
+                shutil.copy2(src_item, dst_item)
+    else:
+        print(f"Source directory {src_dir} does not exist.")
+
+def configure_logging(log_level=logging.INFO):
+    """Configure logging with the specified level"""
+    # Set the root logger level
+    root_logger = logging.getLogger()
+    root_logger.setLevel(log_level)
+    
+    # Configure basic logging format
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    
+    # Add console handler if not already present
+    if not root_logger.handlers:
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(formatter)
+        root_logger.addHandler(console_handler)
+    else:
+        # Update existing handlers' formatters
+        for handler in root_logger.handlers:
+            handler.setFormatter(formatter)
+    
+    # Set level for all handlers
+    for handler in root_logger.handlers:
+        handler.setLevel(log_level)
+
+def create_argument_parser() -> argparse.ArgumentParser:
+    """ """
+    # create the top-level parser
+    parser = argparse.ArgumentParser(
+            prog="cota",
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+            description="cota command line interface."
+    )
+
+    parser.add_argument(
+            "--version",
+            action="store_true",
+            default=argparse.SUPPRESS,
+            help="Print installed cota version"
+    )
+
+    parent_parser = argparse.ArgumentParser(add_help=False)
+    parent_parsers = [parent_parser]
+
+    subparsers = parser.add_subparsers(help="cota commands")
+
+    # create the parser for the "run" command
+    parser_run = subparsers.add_parser(
+            "run",
+            parents=parent_parsers,
+            conflict_handler="resolve",
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+            help="Starts a cota server."
+    )
+
+    parser_run.add_argument('--host', default='0.0.0.0', type=str, help="Host to run the service")
+    parser_run.add_argument('--port', default=5005, type=int, help="Port to run the service")
+    parser_run.add_argument('--config', default='./', type=str, help="agent config")
+    parser_run.add_argument('--channel', default='socket.io', type=str, help="Message channel")
+    parser_run.add_argument('--debug', action='store_true', help="Enable debug mode (sets log level to DEBUG)")
+    parser_run.add_argument('--log', default='INFO', type=str, help="Set the logging level")
+    parser_run.add_argument('--ssl-cert', type=str, help="SSL certificate file path")
+    parser_run.add_argument('--ssl-key', type=str, help="SSL private key file path")
+    def run_with_debug(args):
+        if args.debug:
+            args.log = 'DEBUG'
+        configure_logging(getattr(logging, args.log.upper(), logging.INFO))
+        run(args)
+    parser_run.set_defaults(func=run_with_debug)
+
+    # create the parser for the "shell" command
+    parser_shell = subparsers.add_parser(
+        "shell",
+        parents=parent_parsers,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Interacting with cota by commandline."
+    )
+
+    parser_shell.add_argument('--config', default='./', type=str, help="agent config path")
+    parser_shell.add_argument('--log', default='INFO', type=str, help="Set the logging level")
+    parser_shell.add_argument('--debug', action='store_true', help="Enable debug mode (sets log level to DEBUG)")
+    
+    def run_shell(args):
+        if args.debug:
+            args.log = 'DEBUG'
+        configure_logging(getattr(logging, args.log.upper(), logging.INFO))
+        return asyncio.run(shell(args))
+    
+    parser_shell.set_defaults(func=run_shell)
+
+    # create the parser for the "task" command
+    parser_task = subparsers.add_parser(
+        "task",
+        parents=parent_parsers,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Executing cota in task mode."
+    )
+
+    parser_task.add_argument('--config', default='./', type=str, help="task config path")
+    parser_task.add_argument('--log', default='INFO', type=str, help="Set the logging level")
+    parser_task.add_argument('--debug', action='store_true', help="Enable debug mode (sets log level to DEBUG)")
+    
+    def run_task(args):
+        if args.debug:
+            args.log = 'DEBUG'
+        configure_logging(getattr(logging, args.log.upper(), logging.INFO))
+        return asyncio.run(task(args))
+    
+    parser_task.set_defaults(func=run_task)
+
+    # create the parser for the "init" command
+    parser_init = subparsers.add_parser(
+        "init",
+        parents=parent_parsers,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Initialize a new cota project."
+    )
+    parser_init.add_argument('--log', default='INFO', type=str, help="Set the logging level")
+    parser_init.set_defaults(func=init)
+
+    return parser
+
+def main():
+    parser = create_argument_parser()
+    cmdline_arguments = parser.parse_args()
+
+    if hasattr(cmdline_arguments, "func"):
+        log_level = getattr(logging, cmdline_arguments.log.upper())
+        configure_logging(log_level)
+        cmdline_arguments.func(cmdline_arguments)
+    elif hasattr(cmdline_arguments, "version"):
+        print(f"Cota version: {__version__}")
+
+
+if __name__ == "__main__":
+    main()

cota/actions/__init__.py

@@ -0,0 +1,6 @@
+from cota.actions.action import Action
+from cota.actions.user_utter import UserUtter
+from cota.actions.bot_utter import BotUtter
+from cota.actions.selector import Selector
+from cota.actions.form import Form
+from cota.actions.rag import RAG

cota/actions/action.py

@@ -0,0 +1,93 @@
+import time
+from typing import Text, Optional, Any, Dict, List
+
+registry = []
+
+
+class Action:
+    def __init__(
+            self,
+            name: Optional[Text] = None,
+            description: Optional[Text] = None,
+            prompt: Optional[Text] = None,
+            llm: Optional[Text] = None,
+            timestamp: Optional[float] = None,
+            sender_id: Optional[Text] = None,
+            receiver_id: Optional[Text] = None,
+            result: Optional[List] = None
+    ) -> None:
+        self.name = name
+        self.description = description
+        self.prompt = prompt
+        self.llm = llm
+        self.timestamp = timestamp or time.time()
+        self.sender_id = sender_id or 'default_sender'
+        self.receiver_id = receiver_id or 'default_receiver'
+        self.result = result or list()
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        registry.append(cls)
+
+    @staticmethod
+    def resolve_by_type(
+            name: Text
+    ) -> "Action":
+        # Try exact match first
+        for cls in registry:
+            if cls.__name__ == name:
+                return cls
+        
+        # Try case-insensitive match
+        name_lower = name.lower()
+        for cls in registry:
+            if cls.__name__.lower() == name_lower:
+                return cls
+        
+        # if not in register
+        new_class = type(name, (Action,), {})
+        new_class.__name__ = name
+        return new_class
+
+
+    def apply_to(self,dst) -> None:
+        dst.actions.append(self)
+        dst.latest_action = self
+
+    @staticmethod
+    def build_from_name(**kwargs) -> "Action":
+        action_class = Action.resolve_by_type(kwargs.get("name"))
+        if not action_class:
+            return None
+        return action_class(**kwargs)
+
+    def run_from_dict(
+            self,
+            action_dict
+    ) -> None:
+        self.name = action_dict.get("name") or self.name
+        self.timestamp = action_dict.get("timestamp") or self.timestamp
+        self.sender_id = action_dict.get("sender_id") or self.sender_id
+        self.receiver_id = action_dict.get("receiver_id") or self.receiver_id
+        self.result = action_dict.get("result")
+
+    def run_from_string(
+            self,
+            text
+    ) -> None:
+        """Implementation based on string"""
+        raise NotImplementedError
+
+    async def run(self, agent, dst) -> None:
+        raise NotImplementedError
+
+    def as_dict(self) -> Dict[Text, Any]:
+        d = {
+            "name": self.__class__.__name__,
+            "timestamp": self.timestamp,
+            "sender_id": self.sender_id,
+            "receiver_id": self.receiver_id
+        }
+        if self.result:
+            d["result"] = self.result
+        return d

cota/actions/bot_utter.py

@@ -0,0 +1,118 @@
+import logging
+import json
+from typing import Optional, Dict, Any, List
+from cota.actions.action import Action
+from cota.message.message import Message
+from cota.dst import DST
+from cota.constant import DEFAULT_DIALOGUE_MAX_TOKENS
+
+logger = logging.getLogger(__name__)
+
+
+class BotUtter(Action):
+    """
+    Bot utterance action that generates responses using LLM with JSON output support.
+    
+    This action processes prompts through the dialogue state tracker (DST),
+    formats them with RAG and thought context, and generates bot responses
+    using the configured language model. The LLM is instructed to return
+    responses in JSON format with 'text' and 'thought' fields.
+    
+    Expected JSON response format:
+    {
+        "text": "The main response content",
+        "thought": "Internal reasoning or thought process"  
+    }
+    
+    The 'thought' content is stored at the same level as 'text' for analysis and debugging.
+    """
+    def apply_to(self, dst: DST) -> None:
+        """
+        Apply this action to the dialogue state tracker.
+        
+        Args:
+            dst: The dialogue state tracker to update
+        """
+        if dst is None:
+            raise ValueError("DST cannot be None")
+            
+        dst.actions.append(self)
+        dst.formless_actions.append(self)
+        dst.latest_action = self
+        dst.latest_response = self
+
+    def run_from_string(self, text: str) -> None:
+        """
+        Create a bot message from a string and add it to results.
+        
+        Args:
+            text: The text content for the bot message
+        """
+        if not text:
+            logger.warning("Empty text provided to run_from_string")
+            return
+            
+        if not hasattr(self, 'result'):
+            self.result = []
+            
+        message = Message(sender='bot', text=text)
+        self.result.append(message.as_dict())
+
+    async def run(
+            self,
+            agent: Optional["Agent"] = None,
+            dst: Optional[DST] = None,
+    ):
+        knowledge_dict = await dst.format_knowledge(self.prompt, self)
+        thoughts_dict = await dst.format_policies(self.prompt, self)
+        prompt = dst.format_prompt(self.prompt, self, {**knowledge_dict, **thoughts_dict})
+
+        messages = [
+            {
+                "role": "system",
+                "content": dst.agent_description()
+            },
+            {
+                "role": "user",
+                "content": prompt
+            }
+        ]
+        
+        # Generate response with JSON format requirement
+        result = await agent.llm_instance(self.llm).generate_chat(
+            messages=messages,
+            max_tokens=agent.dialogue.get('max_tokens', DEFAULT_DIALOGUE_MAX_TOKENS),
+            response_format={'type': 'json_object'}
+        )
+
+        # Parse JSON response from content field
+        content = result["content"]
+        try:
+            json_result = json.loads(content)
+            text_content = json_result.get('text', '')
+            thought_content = json_result.get('thought', '')
+            
+            logger.debug(f"Parsed JSON result: {json_result}")
+        except json.JSONDecodeError:
+            logger.error(f"Failed to parse JSON response from bot: {content}")
+            # Fallback to original text if JSON parsing fails
+            text_content = content
+            thought_content = ''
+
+        # Create message with text content
+        message = Message(sender='bot', sender_id=agent.name, text=text_content)
+        
+        # Create message dict and add thought at the same level as text
+        message_dict = message.as_dict()
+        if thought_content:
+            message_dict['thought'] = thought_content
+
+        if self.result and self.result[-1].get('text') is None:
+            self.result[-1].update({
+                key: value for key, value in message_dict.items() if value is not None
+            })
+        else:
+            self.result.append(message_dict)
+
+        logger.debug(f"Response prompt: {prompt}")
+        logger.debug(f"Response result: {self.result}")

cota/actions/executors/base.py

@@ -0,0 +1,63 @@
+from typing import Dict, Text, Tuple, Any
+from abc import ABC, abstractmethod
+
+class Executor(ABC):
+    """Base executor class
+    
+    Defines the basic interface for executors, all concrete executors should inherit from this class.
+    """
+    
+    def __init__(self, config: Dict[Text, Any]) -> None:
+        self.config = config
+    
+    @abstractmethod
+    async def execute(self, data: Dict[Text, Any]) -> Tuple[Text, Dict]:
+        """Execute specific operation
+        
+        Args:
+            data: Data required for execution
+            
+        Returns:
+            Tuple[Response text, Metadata]
+        """
+        pass
+    
+    async def cleanup(self) -> None:
+        """Clean up resources
+        
+        Subclasses can override this method to implement resource cleanup logic.
+        """
+        pass
+    
+    @classmethod
+    def create(cls, executor_type: Text, config: Dict[Text, Any]) -> "Executor":
+        """Create executor instance
+        
+        Args:
+            executor_type: Executor type
+            config: Executor configuration
+            
+        Returns:
+            Executor: Executor instance
+        """
+        from .http import HttpExecutor
+        from .script import ScriptExecutor
+        from .python import PythonExecutor
+        from .plugin import PluginExecutor
+        
+        executor_map = {
+            "http": HttpExecutor,
+            "script": ScriptExecutor,
+            "python": PythonExecutor,
+            "plugin": PluginExecutor
+        }
+        
+        executor_class = executor_map.get(executor_type)
+        if not executor_class:
+            raise ValueError(f"Unknown executor type: {executor_type}")
+            
+        # Remove type information as it has been used
+        config = config.copy()
+        config.pop("type", None)
+            
+        return executor_class(config) 

cota/actions/executors/http.py

@@ -0,0 +1,44 @@
+import logging
+from typing import Dict, Text, Tuple, Any
+from .base import Executor
+from cota.utils.http import HttpClientManager
+
+logger = logging.getLogger(__name__)
+
+class HttpExecutor(Executor):
+    """HTTP executor
+    
+    Handles execution logic based on HTTP requests.
+    """
+    
+    async def execute(self, data: Dict[Text, Any]) -> Tuple[Text, Dict]:
+        """Execute HTTP request
+        
+        Args:
+            data: Request data
+            
+        Returns:
+            Tuple[Response text, Metadata]
+        """
+        url = self.config.get("url", "")
+        method = self.config.get("method", "get").upper()
+        
+        try:
+            # Get HTTP client
+            client = await HttpClientManager.instance().get_client(
+                self.config.get("client_key", "default")
+            )
+            
+            # Execute request
+            if method == "GET":
+                response = await client.get(url, params=data)
+            else:
+                response = await client.request(method, url, json_data=data)
+            
+            if not response.ok:
+                raise Exception(f"Request failed with status {response.status}")
+                
+            return response.data.get("text", ""), response.data.get("metadata", {})
+        except Exception as e:
+            logger.error(f"Failed to execute HTTP request: {str(e)}")
+            return "", {"error": str(e)}