Update main.py

main.py

@@ -1,7 +1,6 @@
-from fastapi import FastAPI, HTTPException, Depends
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-from typing import List, Optional, Dict, Any
-from web3 import Web3
+from typing import List, Optional
 from ctransformers import AutoModelForCausalLM
 import os
 import uuid
@@ -10,13 +9,13 @@ import re
 
 # ============== Pydantic Models ==============
 
-class TransferRequest(BaseModel):
-    recipient_address: str
-    execute_transfer: bool = False
-
 class Validation(BaseModel):
     prompt: str
 
+class EthConversionRequest(BaseModel):
+    value: float
+    from_unit: str = "eth"  # eth, gwei, or wei
+
 # OpenAI-compatible models
 class Message(BaseModel):
     role: str
@@ -54,16 +53,21 @@ app = FastAPI(
     description="""
     ## Luminous Coding Assistant API
     
-    OpenAI-compatible API powered by Qwen2.5-Coder-7B for code generation and assistance, you can run this in the cursor agent view.
+    OpenAI-compatible API powered by Qwen2.5-Coder-7B for code generation and assistance.
     
     ### Features
-    * 🤖 AI-powered code generation
-    * 🔗 Web3 integration for Base network
-    * 📊 Counter utilities
-    * 💰 ETH transfer capabilities x402 (todo)
+    * 🤖 AI-powered code generation with Qwen2.5-Coder
+    * 🔌 OpenAI-compatible endpoints for Cursor IDE integration
+    * 💰 ETH unit conversion utilities (Wei ↔ Gwei ↔ ETH)
+    * 💻 Optimized for coding tasks and assistance
+    
+    ### Integration with Cursor IDE
+    1. Go to Cursor Settings → Models → Override OpenAI Base URL
+    2. Set Base URL: `https://jeeltcraft-luminous.hf.space/v1`
+    3. Model name: `qwen2.5-coder-7b`
+    4. Add any dummy API key
     """,
-    version="1.1.0",
-    terms_of_service="https://huggingface.co/spaces/jeeltcraft/Luminous",
+    version="1.0.0",
     contact={
         "name": "Jeeltcraft",
         "url": "https://huggingface.co/jeeltcraft",
@@ -82,26 +86,18 @@ app = FastAPI(
         },
         {
             "name": "Utilities",
-            "description": "Counter and helper functions",
-        },
-        {
-            "name": "Web3",
-            "description": "Blockchain x402 operations on Base network",
+            "description": "ETH conversion and helper functions",
         },
     ],
     swagger_ui_parameters={
         "deepLinking": True,
         "displayRequestDuration": True,
-        "docExpansion": "none",  # Collapse all sections by default
-        "syntaxHighlight.theme": "monokai",  # Code highlighting theme
+        "docExpansion": "none",
+        "syntaxHighlight.theme": "monokai",
         "defaultModelsExpandDepth": 2,
     }
 )
 
-
-# Global counter
-counter = 0
-
 # Global variable to hold the model
 _llm_model = None
 
@@ -155,54 +151,89 @@ def call_llm(prompt: str) -> str:
 
 # ============== Helper Functions ==============
 
-def increment_and_print(value: int):
-    global counter
-    counter += value
-    print(f"Counter: {counter}")
-    return counter
-
-# ============== Web3 Functions ==============
-
-# Web3 setup
-BASE_RPC_URL = "https://mainnet.base.org"
-w3 = Web3(Web3.HTTPProvider(BASE_RPC_URL))
-
-def get_private_key():
-    private_key = os.environ.get("LumKey")
-    if not private_key:
-        raise HTTPException(status_code=500, detail="Private key not found in secrets.")
-    return private_key
-
-def transfer_eth(recipient_address: str, private_key: str):
-    try:
-        account = w3.eth.account.from_key(private_key)
-        sender_address = account.address
-
-        nonce = w3.eth.get_transaction_count(sender_address)
-
-        tx = {
-            'nonce': nonce,
-            'to': w3.to_checksum_address(recipient_address),
-            'value': w3.to_wei(0.001, 'ether'),
-            'gas': 21000,
-            'gasPrice': w3.eth.gas_price,
-            'chainId': 8453,
+def convert_eth_units(value: float, from_unit: str = "eth") -> dict:
+    """
+    Convert ETH value to wei and gwei.
+    
+    Args:
+        value: The numeric value to convert
+        from_unit: The source unit ('eth', 'gwei', or 'wei')
+    
+    Returns:
+        Dictionary with conversions to all units
+    """
+    # Convert input to wei first
+    if from_unit.lower() == "eth":
+        wei_value = int(value * 10**18)
+    elif from_unit.lower() == "gwei":
+        wei_value = int(value * 10**9)
+    elif from_unit.lower() == "wei":
+        wei_value = int(value)
+    else:
+        raise ValueError("Invalid unit. Use 'eth', 'gwei', or 'wei'")
+    
+    # Convert wei to all units
+    eth_value = wei_value / 10**18
+    gwei_value = wei_value / 10**9
+    
+    return {
+        "input": {
+            "value": value,
+            "unit": from_unit
+        },
+        "conversions": {
+            "wei": str(wei_value),  # String to avoid JavaScript number overflow
+            "gwei": gwei_value,
+            "eth": eth_value
+        },
+        "formatted": {
+            "wei": f"{wei_value:,} wei",
+            "gwei": f"{gwei_value:,.2f} gwei",
+            "eth": f"{eth_value:.18f} ETH"
         }
-
-        signed_tx = account.sign_transaction(tx)
-        tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
-
-        return w3.to_hex(tx_hash)
-
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Transaction failed: {str(e)}")
+    }
 
 # ============== OpenAI-Compatible Endpoints ==============
 
-@app.post("/v1/chat/completions", response_model=ChatCompletionResponse)
+@app.post(
+    "/v1/chat/completions",
+    response_model=ChatCompletionResponse,
+    tags=["OpenAI Compatible"],
+    summary="Create chat completion",
+    response_description="Returns the model's response to the conversation"
+)
 async def chat_completions(request: ChatCompletionRequest):
     """
-    OpenAI-compatible chat completions endpoint for Cursor integration
+    Create a chat completion using OpenAI-compatible format.
+    
+    This endpoint is designed for integration with Cursor IDE and other
+    OpenAI-compatible clients. It accepts a conversation history and returns
+    the model's response.
+    
+    ## Parameters
+    - **model**: Model identifier (use `qwen2.5-coder-7b` for this API)
+    - **messages**: Array of conversation messages with role and content
+        - Role can be: `system`, `user`, or `assistant`
+    - **temperature**: Controls randomness (0.0 = deterministic, 2.0 = very random)
+    - **max_tokens**: Maximum number of tokens to generate in the response
+    - **stream**: Whether to stream the response (not yet implemented)
+    
+    ## Example Request
+    ```json
+    {
+        "model": "qwen2.5-coder-7b",
+        "messages": [
+            {"role": "system", "content": "You are a helpful coding assistant."},
+            {"role": "user", "content": "Write a Python function to reverse a string"}
+        ],
+        "temperature": 0.7,
+        "max_tokens": 512
+    }
+    ```
+    
+    ## Returns
+    A chat completion response with the model's generated text, token usage,
+    and other metadata.
     """
     try:
         # Extract the last user message from conversation history
@@ -212,7 +243,6 @@ async def chat_completions(request: ChatCompletionRequest):
         )
         
         # Format prompt for Qwen2.5-Coder
-        # Qwen uses a different format than Zephyr
         formatted_prompt = f"<|im_start|>system\nYou are a helpful coding assistant.<|im_end|>\n<|im_start|>user\n{user_message}<|im_end|>\n<|im_start|>assistant\n"
         
         # Call your LLM
@@ -242,10 +272,18 @@ async def chat_completions(request: ChatCompletionRequest):
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
 
-@app.get("/v1/models")
+@app.get(
+    "/v1/models",
+    tags=["OpenAI Compatible"],
+    summary="List available models",
+    response_description="Returns a list of available models"
+)
 async def list_models():
     """
-    OpenAI-compatible models endpoint
+    List all available models in OpenAI-compatible format.
+    
+    This endpoint returns the models available through this API.
+    Use the model ID when making requests to `/v1/chat/completions`.
     """
     return {
         "object": "list",
@@ -259,56 +297,176 @@ async def list_models():
         ]
     }
 
-# ============== Original Endpoints ==============
+# ============== Direct LLM Endpoints ==============
 
-@app.post("/llm_on_cpu")
+@app.post(
+    "/llm_on_cpu",
+    tags=["LLM"],
+    summary="Direct LLM inference",
+    response_description="Returns the model's raw response"
+)
 async def stream(item: Validation):
+    """
+    Direct inference endpoint for simple prompts.
+    
+    This endpoint provides direct access to the LLM without the OpenAI wrapper.
+    Useful for custom prompt formatting.
+    
+    - **prompt**: Your input text prompt
+    """
     system_prompt = 'Below is an instruction that describes a task. Write a response that appropriately completes the request.'
     E_INST = "</s>"
     user, assistant = "<|user|>", "<|assistant|>"
     prompt = f"{system_prompt}{E_INST}\n{user}\n{item.prompt.strip()}{E_INST}\n{assistant}\n"
     return {"response": call_llm(prompt)}
 
-@app.post("/increment_from_prompt")
-async def increment_from_prompt(item: Validation):
-    match = re.search(r'\d+', item.prompt)
-    if match:
-        increment_value = int(match.group())
-        result = increment_and_print(increment_value)
-    else:
-        result = increment_and_print(0)
-    return {"counter": result}
+# ============== Utility Endpoints ==============
 
-@app.post("/increment_counter")
-async def increment():
-    result = increment_and_print(1)
-    return {"counter": result}
+@app.post(
+    "/convert_eth_units",
+    tags=["Utilities"],
+    summary="Convert ETH units (ETH ↔ Gwei ↔ Wei)",
+    response_description="Returns conversions to all ETH units"
+)
+async def convert_units(request: EthConversionRequest):
+    """
+    Convert between Ethereum units: ETH, Gwei, and Wei.
+    
+    ## Ethereum Units Explained
+    - **ETH**: The base unit (1 ETH = 1,000,000,000,000,000,000 wei)
+    - **Gwei**: Gigawei, commonly used for gas prices (1 Gwei = 1,000,000,000 wei)
+    - **Wei**: The smallest unit of Ether (1 wei = 0.000000000000000001 ETH)
+    
+    ## Parameters
+    - **value**: The numeric value to convert
+    - **from_unit**: Source unit - `eth`, `gwei`, or `wei` (default: `eth`)
+    
+    ## Example Requests
+    
+    Convert 1 ETH to all units:
+    ```json
+    {
+        "value": 1,
+        "from_unit": "eth"
+    }
+    ```
+    
+    Convert 50 Gwei to all units:
+    ```json
+    {
+        "value": 50,
+        "from_unit": "gwei"
+    }
+    ```
+    
+    ## Returns
+    Conversions to Wei, Gwei, and ETH with both numeric and formatted values.
+    """
+    try:
+        result = convert_eth_units(request.value, request.from_unit)
+        return result
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Conversion error: {str(e)}")
 
-@app.post("/reward")
-async def reward_endpoint(request: TransferRequest, private_key: str = Depends(get_private_key)):
-    if request.execute_transfer:
-        try:
-            tx_hash = transfer_eth(request.recipient_address, private_key)
-            return {"transaction_hash": tx_hash}
-        except HTTPException as e:
-            raise e
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=str(e))
-    else:
-        return {"message": "Transaction blocked by execute_transfer flag."}
+@app.post(
+    "/eth_to_units",
+    tags=["Utilities"],
+    summary="Quick convert: ETH to Wei/Gwei",
+    response_description="Returns Wei and Gwei values"
+)
+async def eth_to_units(item: Validation):
+    """
+    Quick converter: Extract a number from text and convert from ETH to Wei and Gwei.
+    
+    This endpoint extracts the first number found in the prompt and treats it as ETH,
+    then converts it to Wei and Gwei. Useful for quick conversions in chat interfaces.
+    
+    ## Example
+    Send prompt: `"Convert 0.5 ETH"` or just `"0.5"`
+    
+    Returns the value in Wei and Gwei.
+    
+    - **prompt**: Text containing an ETH amount (number will be extracted)
+    """
+    try:
+        # Extract number from prompt
+        match = re.search(r'\d+\.?\d*', item.prompt)
+        if match:
+            eth_value = float(match.group())
+            result = convert_eth_units(eth_value, "eth")
+            return result
+        else:
+            raise HTTPException(status_code=400, detail="No numeric value found in prompt")
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Conversion error: {str(e)}")
+
+@app.get(
+    "/quick_convert/{value}/{unit}",
+    tags=["Utilities"],
+    summary="Quick URL-based ETH conversion",
+    response_description="Returns conversions to all units"
+)
+async def quick_convert(value: float, unit: str = "eth"):
+    """
+    Quick conversion via URL path parameters.
+    
+    ## Usage Examples
+    - `/quick_convert/1/eth` - Convert 1 ETH to Wei and Gwei
+    - `/quick_convert/50/gwei` - Convert 50 Gwei to ETH and Wei
+    - `/quick_convert/1000000000/wei` - Convert 1,000,000,000 Wei to ETH and Gwei
+    
+    ## Parameters
+    - **value**: Numeric amount to convert
+    - **unit**: Source unit (`eth`, `gwei`, or `wei`)
+    """
+    try:
+        result = convert_eth_units(value, unit)
+        return result
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Conversion error: {str(e)}")
 
-@app.get("/")
+# ============== Health & Info Endpoints ==============
+
+@app.get(
+    "/",
+    tags=["Utilities"],
+    summary="API root information",
+    response_description="Returns API status and information"
+)
 async def root():
+    """
+    Get basic information about the API.
+    
+    Returns the API name, status, and current model being used.
+    """
     return {
         "message": "Luminous API - OpenAI Compatible Coding Assistant",
         "status": "active",
-        "model": "Qwen2.5-Coder-7B-Instruct"
+        "model": "Qwen2.5-Coder-7B-Instruct",
+        "docs": "/docs",
+        "openapi": "/openapi.json"
     }
 
-@app.get("/health")
+@app.get(
+    "/health",
+    tags=["Utilities"],
+    summary="Health check",
+    response_description="Returns health status and diagnostics"
+)
 async def health_check():
+    """
+    Check the health status of the API.
+    
+    Returns information about model loading status.
+    """
     return {
         "status": "healthy",
         "model_loaded": _llm_model is not None,
-        "counter": counter
-    }
+        "api_version": "1.0.0"
+    }