mcli-framework 7.5.1__py3-none-any.whl → 7.6.0__py3-none-any.whl

mcli/app/completion_helpers.py

@@ -183,22 +183,13 @@ class CompletionAwareLazyGroup(click.Group):
         group = self._load_group()
         return group.list_commands(ctx)
 
-    def shell_complete(self, ctx, incomplete):
+    def shell_complete(self, ctx, param, incomplete):
         """Provide shell completion using static data when possible."""
-        # For workflow group, provide static subcommand completions
-        if self.name in LAZY_COMMAND_COMPLETIONS:
-            data = LAZY_COMMAND_COMPLETIONS[self.name]
-            if "subcommands" in data:
-                items = []
-                for subcommand in data["subcommands"]:
-                    if subcommand.startswith(incomplete):
-                        items.append(CompletionItem(subcommand))
-                return items
-
-        # Fallback to loading the actual group
+        # Load the actual group to get proper completion for nested commands
+        # This ensures file path completion works for subcommands
         group = self._load_group()
         if hasattr(group, "shell_complete"):
-            return group.shell_complete(ctx, incomplete)
+            return group.shell_complete(ctx, param, incomplete)
         return []
 
     def get_params(self, ctx):

mcli/app/main.py

@@ -255,9 +255,11 @@ class LazyCommand(click.Command):
     def shell_complete(self, ctx, param, incomplete):
         """Provide shell completion for the lazily loaded command."""
         cmd = self._load_command()
+        # Delegate to the loaded command's completion
         if hasattr(cmd, "shell_complete"):
             return cmd.shell_complete(ctx, param, incomplete)
-        return []
+        # Fallback to default Click completion
+        return super().shell_complete(ctx, param, incomplete) if hasattr(super(), "shell_complete") else []
 
 
 class LazyGroup(click.Group):
@@ -309,9 +311,11 @@ class LazyGroup(click.Group):
     def shell_complete(self, ctx, param, incomplete):
         """Provide shell completion for the lazily loaded group."""
         group = self._load_group()
+        # Delegate to the loaded group's completion
         if hasattr(group, "shell_complete"):
             return group.shell_complete(ctx, param, incomplete)
-        return []
+        # Fallback to default Click completion
+        return super().shell_complete(ctx, param, incomplete) if hasattr(super(), "shell_complete") else []
 
 
 def _add_lazy_commands(app: click.Group):
@@ -334,14 +338,14 @@ def _add_lazy_commands(app: click.Group):
     except Exception as e:
         logger.debug(f"Could not load self commands: {e}")
 
-    # Shell completion - load immediately as it's lightweight and useful
+    # Test group - load immediately for testing commands
     try:
-        from mcli.app.completion_cmd import completion
+        from mcli.test.test_cmd import test_group
 
-        app.add_command(completion, name="completion")
-        logger.debug("Added completion commands")
-    except ImportError as e:
-        logger.debug(f"Could not load completion commands: {e}")
+        app.add_command(test_group, name="test")
+        logger.debug("Added test group commands")
+    except Exception as e:
+        logger.debug(f"Could not load test commands: {e}")
 
     # Add workflow with completion-aware lazy loading
     try:
@@ -374,22 +378,6 @@ def _add_lazy_commands(app: click.Group):
             "import_path": "mcli.app.model_cmd.model",
             "help": "Model management commands for offline and online model usage",
         },
-        "cron-test": {
-            "import_path": "mcli.app.cron_test_cmd.cron_test",
-            "help": "🕒 Validate and test MCLI cron/scheduler functionality with comprehensive tests.",
-        },
-        "visual": {
-            "import_path": "mcli.app.visual_cmd.visual",
-            "help": "🎨 Visual effects and enhancements showcase",
-        },
-        "redis": {
-            "import_path": "mcli.app.redis_cmd.redis_group",
-            "help": "🗄️  Manage Redis cache service for performance optimization",
-        },
-        "logs": {
-            "import_path": "mcli.app.logs_cmd.logs_group",
-            "help": "📋 Stream and manage MCLI log files with real-time updates",
-        },
     }
 
     for cmd_name, cmd_info in lazy_commands.items():
@@ -397,7 +385,7 @@ def _add_lazy_commands(app: click.Group):
         if cmd_name == "workflow":
             continue
 
-        if cmd_name in ["model", "redis", "logs"]:
+        if cmd_name in ["model"]:
             # Use completion-aware LazyGroup for commands that have subcommands
             try:
                 from mcli.app.completion_helpers import create_completion_aware_lazy_group

mcli/app/model_cmd.py

@@ -18,6 +18,86 @@ from mcli.workflow.model_service.lightweight_model_server import (
 logger = get_logger(__name__)
 
 
+def _start_openai_server(server, host: str, port: int, api_key: Optional[str], model: str):
+    """Start FastAPI server with OpenAI compatibility"""
+    try:
+        from fastapi import FastAPI
+        from fastapi.middleware.cors import CORSMiddleware
+        import uvicorn
+
+        from mcli.workflow.model_service.openai_adapter import create_openai_adapter
+
+        # Create FastAPI app
+        app = FastAPI(
+            title="MCLI Model Service (OpenAI Compatible)",
+            description="OpenAI-compatible API for MCLI lightweight models",
+            version="1.0.0",
+        )
+
+        # Add CORS middleware
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
+        # Create OpenAI adapter
+        require_auth = api_key is not None
+        adapter = create_openai_adapter(server, require_auth=require_auth)
+
+        # Add API key if provided
+        if api_key:
+            adapter.api_key_manager.add_key(api_key, name="default")
+            click.echo(f"🔐 API key authentication enabled")
+
+        # Include OpenAI routes
+        app.include_router(adapter.router)
+
+        # Add health check endpoint
+        @app.get("/health")
+        async def health():
+            return {"status": "healthy", "model": model}
+
+        # Display server info
+        click.echo(f"\n📝 Server running at:")
+        click.echo(f"   - Base URL: http://{host}:{port}")
+        click.echo(f"   - OpenAI API: http://{host}:{port}/v1")
+        click.echo(f"   - Models: http://{host}:{port}/v1/models")
+        click.echo(f"   - Chat: http://{host}:{port}/v1/chat/completions")
+        click.echo(f"   - Health: http://{host}:{port}/health")
+
+        if require_auth:
+            click.echo(f"\n🔐 Authentication: Required")
+            click.echo(f"   Use: Authorization: Bearer {api_key}")
+        else:
+            click.echo(f"\n⚠️  Authentication: Disabled (not recommended for public access)")
+
+        if host == "0.0.0.0":
+            click.echo(f"\n⚠️  Server is publicly accessible on all interfaces!")
+
+        click.echo(f"\n📚 For aider, use:")
+        if require_auth:
+            click.echo(f"   export OPENAI_API_KEY={api_key}")
+        click.echo(f"   export OPENAI_API_BASE=http://{host}:{port}/v1")
+        click.echo(f"   aider --model {model}")
+
+        click.echo(f"\n   Press Ctrl+C to stop the server")
+
+        # Start server
+        uvicorn.run(app, host=host, port=port, log_level="info")
+
+    except ImportError as e:
+        click.echo(f"❌ Missing dependencies for OpenAI-compatible server: {e}")
+        click.echo(f"   Install with: pip install fastapi uvicorn")
+        sys.exit(1)
+    except Exception as e:
+        click.echo(f"❌ Failed to start OpenAI-compatible server: {e}")
+        logger.error(f"Server error: {e}", exc_info=True)
+        sys.exit(1)
+
+
 @click.group()
 def model():
     """Model management commands for offline and online model usage."""
@@ -103,13 +183,34 @@ def download(model_name: str):
 @click.option(
     "--port", "-p", default=None, help="Port to run server on (default: from config or 51234)"
 )
+@click.option(
+    "--host", "-h", default="localhost", help="Host to bind to (use 0.0.0.0 for public access)"
+)
 @click.option(
     "--auto-download",
     is_flag=True,
     default=True,
     help="Automatically download model if not available",
 )
-def start(model: Optional[str], port: Optional[int], auto_download: bool):
+@click.option(
+    "--openai-compatible",
+    is_flag=True,
+    default=False,
+    help="Enable OpenAI-compatible API endpoints",
+)
+@click.option(
+    "--api-key",
+    default=None,
+    help="API key for authentication (if not set, auth is disabled)",
+)
+def start(
+    model: Optional[str],
+    port: Optional[int],
+    host: str,
+    auto_download: bool,
+    openai_compatible: bool,
+    api_key: Optional[str],
+):
     """Start the lightweight model server."""
     # Load port from config if not specified
     if port is None:
@@ -155,15 +256,24 @@ def start(model: Optional[str], port: Optional[int], auto_download: bool):
             click.echo(f"❌ Failed to load {model}")
             sys.exit(1)
 
-    # Start server
-    click.echo(f"🚀 Starting lightweight server on port {port}...")
-    server.start_server()
+    # Start server with OpenAI compatibility if requested
+    if openai_compatible:
+        click.echo(f"🚀 Starting OpenAI-compatible server on {host}:{port}...")
+        _start_openai_server(server, host, port, api_key, model)
+    else:
+        click.echo(f"🚀 Starting lightweight server on {host}:{port}...")
+        server.start_server()
+
+        click.echo(f"\n📝 Server running at:")
+        click.echo(f"   - API: http://{host}:{port}")
+        click.echo(f"   - Health: http://{host}:{port}/health")
+        click.echo(f"   - Models: http://{host}:{port}/models")
+
+        if host == "0.0.0.0":
+            click.echo(f"\n⚠️  Server is publicly accessible!")
+            click.echo(f"   Consider using --openai-compatible with --api-key for security")
 
-    click.echo(f"\n📝 Server running at:")
-    click.echo(f"   - API: http://localhost:{port}")
-    click.echo(f"   - Health: http://localhost:{port}/health")
-    click.echo(f"   - Models: http://localhost:{port}/models")
-    click.echo(f"\n   Press Ctrl+C to stop the server")
+        click.echo(f"\n   Press Ctrl+C to stop the server")
 
     try:
         # Keep server running

mcli/lib/custom_commands.py

@@ -274,12 +274,23 @@ class CustomCommandManager:
                     spec.loader.exec_module(module)
 
                     # Look for a command or command group in the module
+                    # Prioritize Groups over Commands to handle commands with subcommands correctly
                     command_obj = None
+                    found_commands = []
+
                     for attr_name in dir(module):
                         attr = getattr(module, attr_name)
-                        if isinstance(attr, (click.Command, click.Group)):
+                        if isinstance(attr, click.Group):
+                            # Found a group - this takes priority
                             command_obj = attr
                             break
+                        elif isinstance(attr, click.Command):
+                            # Store command for fallback
+                            found_commands.append(attr)
+
+                    # If no group found, use the first command
+                    if not command_obj and found_commands:
+                        command_obj = found_commands[0]
 
                     if command_obj:
                         # Register with the target group

mcli/{app → self}/completion_cmd.py

@@ -27,7 +27,7 @@ def bash_completion(ctx):
 
     # Get the root CLI app
     app = ctx.find_root().command
-    complete = BashComplete(app, {}, "mcli", "complete")
+    complete = BashComplete(app, {}, "mcli", "_MCLI_COMPLETE")
     script = complete.source()
 
     click.echo("# Bash completion script for MCLI")
@@ -44,7 +44,7 @@ def zsh_completion(ctx):
 
     # Get the root CLI app
     app = ctx.find_root().command
-    complete = ZshComplete(app, {}, "mcli", "complete")
+    complete = ZshComplete(app, {}, "mcli", "_MCLI_COMPLETE")
     script = complete.source()
 
     click.echo("# Zsh completion script for MCLI")
@@ -61,7 +61,7 @@ def fish_completion(ctx):
 
     # Get the root CLI app
     app = ctx.find_root().command
-    complete = FishComplete(app, {}, "mcli", "complete")
+    complete = FishComplete(app, {}, "mcli", "_MCLI_COMPLETE")
     script = complete.source()
 
     click.echo("# Fish completion script for MCLI")
@@ -101,7 +101,7 @@ def install_completion(ctx, shell):
         if shell == "bash":
             from click.shell_completion import BashComplete
 
-            complete = BashComplete(app, {}, "mcli", "complete")
+            complete = BashComplete(app, {}, "mcli", "_MCLI_COMPLETE")
             script = complete.source()
 
             # Install to bash completion directory
@@ -130,7 +130,7 @@ def install_completion(ctx, shell):
         elif shell == "zsh":
             from click.shell_completion import ZshComplete
 
-            complete = ZshComplete(app, {}, "mcli", "complete")
+            complete = ZshComplete(app, {}, "mcli", "_MCLI_COMPLETE")
             script = complete.source()
 
             # Install to zsh completion directory
@@ -161,7 +161,7 @@ def install_completion(ctx, shell):
         elif shell == "fish":
             from click.shell_completion import FishComplete
 
-            complete = FishComplete(app, {}, "mcli", "complete")
+            complete = FishComplete(app, {}, "mcli", "_MCLI_COMPLETE")
             script = complete.source()
 
             # Install to fish completion directory

mcli/self/self_cmd.py

@@ -1265,6 +1265,35 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
 # Register the plugin group with self_app
 self_app.add_command(plugin)
 
+# Import and register new commands that have been moved to self
+try:
+    from mcli.self.completion_cmd import completion
+    self_app.add_command(completion, name="completion")
+    logger.debug("Added completion command to self group")
+except ImportError as e:
+    logger.debug(f"Could not load completion command: {e}")
+
+try:
+    from mcli.self.logs_cmd import logs_group
+    self_app.add_command(logs_group, name="logs")
+    logger.debug("Added logs command to self group")
+except ImportError as e:
+    logger.debug(f"Could not load logs command: {e}")
+
+try:
+    from mcli.self.redis_cmd import redis_group
+    self_app.add_command(redis_group, name="redis")
+    logger.debug("Added redis command to self group")
+except ImportError as e:
+    logger.debug(f"Could not load redis command: {e}")
+
+try:
+    from mcli.self.visual_cmd import visual
+    self_app.add_command(visual, name="visual")
+    logger.debug("Added visual command to self group")
+except ImportError as e:
+    logger.debug(f"Could not load visual command: {e}")
+
 # This part is important to make the command available to the CLI
 if __name__ == "__main__":
     self_app()

mcli/test/test_cmd.py

@@ -0,0 +1,30 @@
+"""
+Test command group for mcli.
+Contains testing and validation utilities.
+"""
+
+import click
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+@click.group(name="test")
+def test_group():
+    """Testing and validation commands"""
+    pass
+
+
+# Import and register subcommands
+try:
+    from mcli.test.cron_test_cmd import cron_test
+
+    test_group.add_command(cron_test, name="cron")
+    logger.debug("Added cron test command to test group")
+except ImportError as e:
+    logger.debug(f"Could not load cron test command: {e}")
+
+
+if __name__ == "__main__":
+    test_group()

mcli/workflow/model_service/openai_adapter.py

@@ -0,0 +1,343 @@
+"""
+OpenAI API Adapter for MCLI Model Service
+
+Provides OpenAI-compatible endpoints for tools like aider.
+"""
+
+import json
+import time
+import uuid
+from datetime import datetime
+from typing import Any, AsyncGenerator, Dict, List, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Header, Request, status
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class Message(BaseModel):
+    """OpenAI message format"""
+
+    role: str
+    content: str
+    name: Optional[str] = None
+
+
+class ChatCompletionRequest(BaseModel):
+    """OpenAI chat completion request"""
+
+    model: str
+    messages: List[Message]
+    temperature: Optional[float] = 0.7
+    top_p: Optional[float] = 0.9
+    n: Optional[int] = 1
+    stream: Optional[bool] = False
+    stop: Optional[List[str]] = None
+    max_tokens: Optional[int] = 2048
+    presence_penalty: Optional[float] = 0.0
+    frequency_penalty: Optional[float] = 0.0
+    user: Optional[str] = None
+
+
+class ChatCompletionChoice(BaseModel):
+    """Chat completion choice"""
+
+    index: int
+    message: Message
+    finish_reason: str
+
+
+class Usage(BaseModel):
+    """Token usage information"""
+
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+
+class ChatCompletionResponse(BaseModel):
+    """OpenAI chat completion response"""
+
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: List[ChatCompletionChoice]
+    usage: Usage
+
+
+class ModelInfo(BaseModel):
+    """Model information"""
+
+    id: str
+    object: str = "model"
+    created: int
+    owned_by: str = "mcli"
+
+
+class ModelListResponse(BaseModel):
+    """Model list response"""
+
+    object: str = "list"
+    data: List[ModelInfo]
+
+
+class APIKeyManager:
+    """Manages API key authentication"""
+
+    def __init__(self):
+        self.valid_keys: Dict[str, Dict[str, Any]] = {}
+
+    def add_key(self, key: str, name: str = "default", metadata: Optional[Dict] = None):
+        """Add a valid API key"""
+        self.valid_keys[key] = {
+            "name": name,
+            "created_at": datetime.now().isoformat(),
+            "metadata": metadata or {},
+            "usage_count": 0,
+        }
+
+    def validate_key(self, key: str) -> bool:
+        """Validate an API key"""
+        if key in self.valid_keys:
+            self.valid_keys[key]["usage_count"] += 1
+            return True
+        return False
+
+    def remove_key(self, key: str):
+        """Remove an API key"""
+        if key in self.valid_keys:
+            del self.valid_keys[key]
+
+    def list_keys(self) -> List[Dict[str, Any]]:
+        """List all API keys (without showing the actual key)"""
+        return [
+            {"name": info["name"], "created_at": info["created_at"], "usage_count": info["usage_count"]}
+            for info in self.valid_keys.values()
+        ]
+
+
+class OpenAIAdapter:
+    """Adapter to make MCLI model service OpenAI-compatible"""
+
+    def __init__(self, model_manager, require_auth: bool = True):
+        self.model_manager = model_manager
+        self.require_auth = require_auth
+        self.api_key_manager = APIKeyManager()
+        self.router = APIRouter(prefix="/v1")
+
+        # Setup routes
+        self._setup_routes()
+
+    def _setup_routes(self):
+        """Setup OpenAI-compatible routes"""
+
+        @self.router.get("/models", response_model=ModelListResponse)
+        async def list_models(api_key: str = Depends(self.verify_api_key)):
+            """List available models (OpenAI compatible)"""
+            models = []
+
+            # Get loaded models from model manager
+            if hasattr(self.model_manager, "loaded_models"):
+                for model_name in self.model_manager.loaded_models.keys():
+                    models.append(
+                        ModelInfo(
+                            id=model_name,
+                            object="model",
+                            created=int(time.time()),
+                            owned_by="mcli",
+                        )
+                    )
+
+            # If no models loaded, return available lightweight models
+            if not models:
+                from .lightweight_model_server import LIGHTWEIGHT_MODELS
+
+                for model_key in LIGHTWEIGHT_MODELS.keys():
+                    models.append(
+                        ModelInfo(
+                            id=model_key,
+                            object="model",
+                            created=int(time.time()),
+                            owned_by="mcli",
+                        )
+                    )
+
+            return ModelListResponse(object="list", data=models)
+
+        @self.router.post("/chat/completions")
+        async def create_chat_completion(
+            request: ChatCompletionRequest, api_key: str = Depends(self.verify_api_key)
+        ):
+            """Create a chat completion (OpenAI compatible)"""
+            try:
+                # Extract the conversation history
+                messages = request.messages
+                prompt = self._messages_to_prompt(messages)
+
+                # Generate response using the model
+                if request.stream:
+                    return StreamingResponse(
+                        self._generate_stream(request, prompt), media_type="text/event-stream"
+                    )
+                else:
+                    response_text = await self._generate_response(request, prompt)
+
+                    # Create OpenAI-compatible response
+                    completion_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
+                    response = ChatCompletionResponse(
+                        id=completion_id,
+                        object="chat.completion",
+                        created=int(time.time()),
+                        model=request.model,
+                        choices=[
+                            ChatCompletionChoice(
+                                index=0,
+                                message=Message(role="assistant", content=response_text),
+                                finish_reason="stop",
+                            )
+                        ],
+                        usage=Usage(
+                            prompt_tokens=len(prompt.split()),
+                            completion_tokens=len(response_text.split()),
+                            total_tokens=len(prompt.split()) + len(response_text.split()),
+                        ),
+                    )
+
+                    return response
+
+            except Exception as e:
+                logger.error(f"Error in chat completion: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+
+    def _messages_to_prompt(self, messages: List[Message]) -> str:
+        """Convert OpenAI messages format to a simple prompt"""
+        prompt_parts = []
+
+        for message in messages:
+            role = message.role
+            content = message.content
+
+            if role == "system":
+                prompt_parts.append(f"System: {content}")
+            elif role == "user":
+                prompt_parts.append(f"User: {content}")
+            elif role == "assistant":
+                prompt_parts.append(f"Assistant: {content}")
+
+        return "\n\n".join(prompt_parts)
+
+    async def _generate_response(self, request: ChatCompletionRequest, prompt: str) -> str:
+        """Generate a response from the model"""
+        try:
+            # Use the lightweight model server if available
+            if hasattr(self.model_manager, "loaded_models"):
+                # Get the first loaded model or the requested model
+                model_name = request.model
+                available_models = list(self.model_manager.loaded_models.keys())
+
+                if not available_models:
+                    # Try to auto-load the requested model
+                    from .lightweight_model_server import LIGHTWEIGHT_MODELS
+
+                    if model_name in LIGHTWEIGHT_MODELS:
+                        logger.info(f"Auto-loading model: {model_name}")
+                        success = self.model_manager.download_and_load_model(model_name)
+                        if not success:
+                            raise HTTPException(
+                                status_code=500, detail=f"Failed to load model: {model_name}"
+                            )
+                    else:
+                        raise HTTPException(
+                            status_code=404,
+                            detail=f"Model {model_name} not found. Available models: {list(LIGHTWEIGHT_MODELS.keys())}",
+                        )
+
+                # Generate response (placeholder - would use actual model inference)
+                response = f"This is a response from MCLI model service using {model_name}. In a production environment, this would use the actual model for inference.\n\nYour prompt was: {prompt[:100]}..."
+
+                return response
+            else:
+                return "Model manager not properly initialized"
+
+        except Exception as e:
+            logger.error(f"Error generating response: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def _generate_stream(
+        self, request: ChatCompletionRequest, prompt: str
+    ) -> AsyncGenerator[str, None]:
+        """Generate a streaming response"""
+        completion_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
+
+        # Generate response
+        response_text = await self._generate_response(request, prompt)
+
+        # Stream the response word by word
+        words = response_text.split()
+        for i, word in enumerate(words):
+            chunk = {
+                "id": completion_id,
+                "object": "chat.completion.chunk",
+                "created": int(time.time()),
+                "model": request.model,
+                "choices": [
+                    {
+                        "index": 0,
+                        "delta": {"content": word + " " if i < len(words) - 1 else word},
+                        "finish_reason": None if i < len(words) - 1 else "stop",
+                    }
+                ],
+            }
+
+            yield f"data: {json.dumps(chunk)}\n\n"
+
+        # Send final message
+        yield "data: [DONE]\n\n"
+
+    async def verify_api_key(self, authorization: Optional[str] = Header(None)) -> str:
+        """Verify API key from Authorization header"""
+        if not self.require_auth:
+            return "no-auth-required"
+
+        if not authorization:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Missing API key",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+
+        # Extract API key from "Bearer <key>" format
+        try:
+            scheme, key = authorization.split()
+            if scheme.lower() != "bearer":
+                raise HTTPException(
+                    status_code=status.HTTP_401_UNAUTHORIZED,
+                    detail="Invalid authentication scheme",
+                    headers={"WWW-Authenticate": "Bearer"},
+                )
+        except ValueError:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid authorization header format",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+
+        # Validate the API key
+        if not self.api_key_manager.validate_key(key):
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid API key",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+
+        return key
+
+
+def create_openai_adapter(model_manager, require_auth: bool = True) -> OpenAIAdapter:
+    """Create an OpenAI adapter instance"""
+    return OpenAIAdapter(model_manager, require_auth)

{mcli_framework-7.5.1.dist-info → mcli_framework-7.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 7.5.1
+Version: 7.6.0
 Summary: 🚀 High-performance CLI framework with Rust extensions, AI chat, and stunning visuals
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>

{mcli_framework-7.5.1.dist-info → mcli_framework-7.6.0.dist-info}/RECORD

@@ -2,14 +2,9 @@ mcli/cli.py,sha256=6KTyXn-pmVkAbCDu59PbiNKBwNra5su31ujFFZ6CBOM,389
 mcli/config.toml,sha256=263yEVvP_W9F2zOLssUBgy7amKaRAFQuBrfxcMhKxaQ,1706
 mcli/app/chat_cmd.py,sha256=OJK91iX-f-CL5-m3ECG4IlcbLbsWQpPp7XWuGnb0cVQ,1552
 mcli/app/commands_cmd.py,sha256=0A54cXazYZRe0Zs_tvBRcqDNtyY22WCxSJ4qfxyue2s,32338
-mcli/app/completion_cmd.py,sha256=lHQ_K_BPaj47-16EDEcNKCG_4vjku6ySBgCtVpT_7-E,7718
-mcli/app/completion_helpers.py,sha256=x59zijq2FuLMhAOe7LaIfQdgNiNk30VEt97U7xKM81Y,7833
-mcli/app/cron_test_cmd.py,sha256=Ai4Smg2WxULeiMD5s2m_S_fXdMAAQsKHpSc4iJGSnwI,26156
-mcli/app/logs_cmd.py,sha256=SCzZ4VZs6p42hksun_w4WN33xIZgmq7RjdWX8P2WcT4,15056
-mcli/app/main.py,sha256=axQx8HjH5iTg2E4vyPNXngTQS4zOyZAs_G4tG-k_IOU,19350
-mcli/app/model_cmd.py,sha256=D-_HckRSI6ly8GwIHflK5S92xitlbLtkpSEO7a6x5xs,12889
-mcli/app/redis_cmd.py,sha256=Cl0LQ3Mqt27gLeb542_xw6bJBbIE-CBmWyMmaUTSk8c,9426
-mcli/app/visual_cmd.py,sha256=jXighahHxeM9HANQ2Brk6nKFgi2ZuQBOBH7PE5xhebk,9428
+mcli/app/completion_helpers.py,sha256=e62C6w2N-XoD66GYYHgtvKKoD3kYMuIeBBGzVKbuL04,7497
+mcli/app/main.py,sha256=1IgnVmEkONVAB2VgXAdjPSDtbfrk-zb5uR2P6tAHLJY,18967
+mcli/app/model_cmd.py,sha256=2Rn6KqEfGbQ5VQxNH0-6FgArZMmCTGiRmCtTs80mBGk,16741
 mcli/app/model/model.py,sha256=EUGu_td-hRlbf4OElkdk1-0p7WyuG7sZmb-Ux2-J9KY,39061
 mcli/app/video/video.py,sha256=3TL8vG3XSKzH_Iyy-IHPZOwNtT7js0VqVVNwIgfDvpk,41910
 mcli/chat/chat.py,sha256=tk4laKe2uSVg9JukacSNTQhCFRlzYbaz1Qdkg8Mu_Bw,102138
@@ -17,7 +12,7 @@ mcli/chat/command_rag.py,sha256=Ee8usPyRDRYDWpQ79dI7xbxM8Ljxsy_ym_MnL37nPAo,1936
 mcli/chat/enhanced_chat.py,sha256=e3odh5klewDHIjfNOyvifLzCdHrysDc2IvNVHzTPIh4,27072
 mcli/chat/system_controller.py,sha256=SuGvnIh2QObvM1DMicF3gGyeBkbz_xXS-hOOHjWx5j4,39114
 mcli/chat/system_integration.py,sha256=xQ11thOUswPg8r1HZkId6U3bTCOtMYngt0-mUYYXpt4,40196
-mcli/lib/custom_commands.py,sha256=-DCuvdzdRcXYP05NnkqyJ0N5ck5he8FgEJSkh_QY-l4,14043
+mcli/lib/custom_commands.py,sha256=ss-rr0i_Gk-MgGpqyQ9hMvsvoyRNQadxH0Y8S9ujpmY,14587
 mcli/lib/lib.py,sha256=mlp2INx-UKTOECcA7Kens9yNt2gJi7GbKWFmf4cxj0c,632
 mcli/lib/paths.py,sha256=k6sDwvD8QRzBkBOllvXkokameumpTjpJ7pQrP7z1en0,2455
 mcli/lib/api/api.py,sha256=sPgAIYC8Z7AWV2TCBssNSKotbRggBqNLsbfzbjkhmUY,18558
@@ -147,8 +142,14 @@ mcli/ml/training/train_model.py,sha256=vXgRMsG1jdr9rG7x6uv98y22fbRFtbESox1RmTVEP
 mcli/mygroup/test_cmd.py,sha256=WjzgoH1WFa79wc8A7O6UMuJfookLfgciUNcCMbKHAQQ,21
 mcli/public/public.py,sha256=t9BkO1XV7s3YcoH0bbIpyjZ05UX_vBjaKtKkuDX7wZ0,114
 mcli/public/oi/oi.py,sha256=SQabQWQ1pE67pWYEHwIDc3R93DARJfB6VHk7qxWx9xo,308
-mcli/self/self_cmd.py,sha256=fV8rDD-9_jqFKLYu2P0-XjxoIv0Z1UTaoT4fpr-MDKY,45473
+mcli/self/completion_cmd.py,sha256=FKNVc_4ikWTGbDHybiNZGdxrggvt6A6q1rnzuyFVzVM,7754
+mcli/self/logs_cmd.py,sha256=SCzZ4VZs6p42hksun_w4WN33xIZgmq7RjdWX8P2WcT4,15056
+mcli/self/redis_cmd.py,sha256=Cl0LQ3Mqt27gLeb542_xw6bJBbIE-CBmWyMmaUTSk8c,9426
+mcli/self/self_cmd.py,sha256=ZSms98HrNWlwp-WammkyTct-eYpMBkLFGA9VteHKZh8,46503
 mcli/self/test_cmd.py,sha256=WjzgoH1WFa79wc8A7O6UMuJfookLfgciUNcCMbKHAQQ,21
+mcli/self/visual_cmd.py,sha256=jXighahHxeM9HANQ2Brk6nKFgi2ZuQBOBH7PE5xhebk,9428
+mcli/test/cron_test_cmd.py,sha256=Ai4Smg2WxULeiMD5s2m_S_fXdMAAQsKHpSc4iJGSnwI,26156
+mcli/test/test_cmd.py,sha256=tk4U1Kyt6t9IW4xvXM0JxFlAeu5mJ6bXAiryGhc108U,600
 mcli/workflow/lsh_integration.py,sha256=jop80DUjdOSxmqPb-gX_OBep5f1twViv-pXmkcFqBPY,13314
 mcli/workflow/workflow.py,sha256=P_W5LOB3lowvvlfEp3mGwS3eNq4tpbiUY-poFulAF9E,393
 mcli/workflow/daemon/async_command_database.py,sha256=pvfKYjt0Jg1EPwJ1p2C0M3bsBWvjEs4Ok-Y6-jY0qVI,24873
@@ -171,6 +172,7 @@ mcli/workflow/model_service/lightweight_model_server.py,sha256=VyBrUba1maPHNDzO_
 mcli/workflow/model_service/lightweight_test.py,sha256=J1--5Q8YvJT3Wzhqf0ElDAostRVA2yDs1LkVwkDMf5M,7330
 mcli/workflow/model_service/model_service.py,sha256=pAxxHw4tShkrnWWFBnzsrGGKEFa8ZEv4Mza_C8clK38,69729
 mcli/workflow/model_service/ollama_efficient_runner.py,sha256=fFZLoIfmgbQnMLwnXuH2ya5o_Tu6ww3ERtXg58HbamE,14340
+mcli/workflow/model_service/openai_adapter.py,sha256=TsI8wvrIwv7TlrzK5DVxVy4WVhDDqZztX_MIeetk4Es,11858
 mcli/workflow/model_service/pdf_processor.py,sha256=YgxGPd37L8OUoocrolYKJTwk_VPknbvTtQnOnfpXMYU,13621
 mcli/workflow/model_service/test_efficient_runner.py,sha256=whu93oXrM0Z8HEzcKCc1DlAVY6CeGDXURAsQ0V-gSjo,6355
 mcli/workflow/model_service/test_example.py,sha256=aMSNRyjz5ian6cmHQt_sE5-q10V82iYJDjeAV1rsfJs,9515
@@ -204,9 +206,9 @@ mcli/workflow/scheduler/persistence.py,sha256=SU8-F5wTpTercZvTeAXKlGI7gwHyfmYDhX
 mcli/workflow/scheduler/scheduler.py,sha256=1Ujq9VgL1rSTCAtshuLA2_sodW6HOj0MEZem7Ga-kic,23351
 mcli/workflow/sync/test_cmd.py,sha256=neVgs9zEnKSxlvzDpFkuCGucqnzjrShm2OvJtHibslg,10009
 mcli/workflow/wakatime/wakatime.py,sha256=sEjsUKa3-XyE8Ni6sAb_D3GAY5jDcA30KknW9YTbLTA,142
-mcli_framework-7.5.1.dist-info/licenses/LICENSE,sha256=sahwAMfrJv2-V66HNPTp7A9UmMjxtyejwTZZoWQvEcI,1075
-mcli_framework-7.5.1.dist-info/METADATA,sha256=pL9FFrcSYJVIStDBAPotBxALLHqsi8eWxIiIv6QN6wQ,14802
-mcli_framework-7.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcli_framework-7.5.1.dist-info/entry_points.txt,sha256=dYrZbDIm-KUPsl1wfv600Kx_8sMy89phMkCihbDRgP8,261
-mcli_framework-7.5.1.dist-info/top_level.txt,sha256=_bnO8J2EUkliWivey_1le0UrnocFKmyVMQjbQ8iVXjc,5
-mcli_framework-7.5.1.dist-info/RECORD,,
+mcli_framework-7.6.0.dist-info/licenses/LICENSE,sha256=sahwAMfrJv2-V66HNPTp7A9UmMjxtyejwTZZoWQvEcI,1075
+mcli_framework-7.6.0.dist-info/METADATA,sha256=w8eFipi2tKKMyNkEmJxvQkuGNQ1UxJ8XU0bga9YAvlA,14802
+mcli_framework-7.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcli_framework-7.6.0.dist-info/entry_points.txt,sha256=dYrZbDIm-KUPsl1wfv600Kx_8sMy89phMkCihbDRgP8,261
+mcli_framework-7.6.0.dist-info/top_level.txt,sha256=_bnO8J2EUkliWivey_1le0UrnocFKmyVMQjbQ8iVXjc,5
+mcli_framework-7.6.0.dist-info/RECORD,,