Day before judgement day, judas will strike in an hour

app_old.py

@@ -0,0 +1,215 @@
+import gradio as gr
+import requests
+import json
+import asyncio
+import logging
+from typing import Dict, List, Any, Optional
+
+# Set up logging to help debug issues
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class DolibarrAPI:
+    base_url = "http://localhost/dolibarr/api/index.php"
+    
+    def __init__(self, api_key: str):
+        """
+        Just a constructor, sets up the api key and some other stuff
+
+        Args:
+            api_key (str): Dolibarr user api key
+        """
+        self.api_key = "OKgV53jdbT1p1tKuZrB05eK9z0p9I2YX"
+        self.headers = {
+            'DOLAPIKEY': api_key,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        }
+
+    def _request(self, method: str, endpoint: str, data: Optional[dict] = None, params: Optional[dict] = None) -> Any:
+        """
+        basic method used for making http request to Dolibarr api
+
+        Args:
+            method (str): The type of HTTP  - GET, POST, PUT, DELETE,etc
+            endpoint (str): api endpoint based on the request type - "/invoice" , "/thirdparties",etc
+            data (Optional[dict]) : data to be sent in request body, dictionary
+            params (Optional[dict]) :  dictionary of params to be sent with this request (for GET)
+        """
+        
+        base_url = "http://localhost/dolibarr/api/index.php"
+        url = f"{base_url}{endpoint}"
+        
+        try:
+            response = requests.request(method, url, headers=self.headers, json=data, params=params)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            logger.error(f"API request failed: {e}")
+            return {"error": f"API request failed: {str(e)}"}
+        except json.JSONDecodeError as e:
+            logger.error(f"JSON decode error: {e}")
+            return {"error": f"Invalid JSON response: {str(e)}"}
+
+    # --- GET REQUESTS ------
+    def get_req(self, endpoint: str, params: Optional[dict] = None):
+        return self._request('GET', endpoint, params=params)
+
+    # --- POST requests -----
+    def post_req(self, endpoint: str, params: dict):
+        return self._request("POST", endpoint, data=params)
+
+    # --- PUT requests ----
+    def put_req(self, endpoint: str, params: dict):
+        return self._request("PUT", endpoint, data=params)
+
+    # --- DELETE requests ----
+    def del_req(self, endpoint: str, params: Optional[dict] = None):
+        return self._request("DELETE", endpoint, params=params)
+
+def dolibarr_interface(method: str, endpoint: str, api_key="OKgV53jdbT1p1tKuZrB05eK9z0p9I2YX", payload_str: str = "") -> str:
+    """
+    To orchestrate the API call from start to finish based on simple string and dictionary inputs
+
+    Args:
+        method (str): http method type ( GET, POST, PUT, DELETE,etc)
+        endpoint (str): api endpoint, basically which api to call (/invoices, /thirdparties,/products,etc)
+        api_key : dolibarr api key
+        payload_str (str): payload as JSON string to send as request body
+    """
+    
+    try:
+        api = DolibarrAPI(api_key)
+        method = method.upper()
+        
+        # Parse payload if provided
+        payload = None
+        if payload_str and payload_str.strip():
+            try:
+                payload = json.loads(payload_str)
+            except json.JSONDecodeError as e:
+                return json.dumps({"error": f"Invalid JSON payload: {str(e)}"}, indent=2)
+
+        if method == 'GET':
+            result = api.get_req(endpoint, payload)
+        elif method == 'POST':
+            if not payload:
+                return json.dumps({"error": "POST requests require a payload"}, indent=2)
+            result = api.post_req(endpoint, payload)
+        elif method == 'PUT':
+            if not payload:
+                return json.dumps({"error": "PUT requests require a payload"}, indent=2)
+            result = api.put_req(endpoint, payload)
+        elif method == 'DELETE':
+            result = api.del_req(endpoint, payload)
+        else:
+            return json.dumps({"error": f"Invalid HTTP method '{method}' selected."}, indent=2)
+        
+        cleaned = clean_json_response(result)
+        return json.dumps(cleaned, indent=2)
+    
+    except Exception as e:
+        logger.error(f"Unexpected error in dolibarr_interface: {e}")
+        return json.dumps({"error": f"Unexpected error: {str(e)}"}, indent=2)
+
+def clean_json_response(data: Any) -> Any:
+    """
+    Recursively clean JSON response by removing null values, empty strings, and empty collections.
+    
+    Args:
+        data: The data to clean (can be dict, list, or primitive type)
+    
+    Returns:
+        Cleaned data with null values and empty collections removed
+    """
+    if isinstance(data, dict):
+        return {
+            k: clean_json_response(v)
+            for k, v in data.items()
+            if v is not None and v != "" and clean_json_response(v) is not None
+        }
+    elif isinstance(data, list):
+        cleaned = [clean_json_response(item) for item in data]
+        return [item for item in cleaned if item is not None and item != ""]
+    else:
+        return data
+    
+# Create the Gradio interface with better error handling
+def create_interface():
+    """Create and return the Gradio interface"""
+    
+    demo = gr.Interface(
+        fn=dolibarr_interface,
+        inputs=[
+            gr.Dropdown(
+                choices=["GET", "POST", "PUT", "DELETE"],
+                label="HTTP Method",
+                value="GET"
+            ),
+            gr.Dropdown(
+                choices=["/thirdparties", "/invoices", "/products", "/contacts", "/users"],
+                label="API Endpoint",
+                value="/thirdparties",
+                allow_custom_value=True
+            ),
+            gr.Textbox(
+                label="API Key", 
+                value="OKgV53jdbT1p1tKuZrB05eK9z0p9I2YX"
+            ),
+            gr.Textbox(
+                label="Payload (JSON format)",
+                placeholder='{"ref": "PROD-001", "label": "Product Name", "price": "99.99"}'
+            )
+        ],
+        outputs=gr.Textbox(
+            label="API Response",
+            #lines=10
+        ),
+        title="Dolibarr AI Agent/Personal ERP Assistant",
+        description="Interact with your Dolibarr ERP system through API calls. Select method, endpoint, and provide JSON payload for POST/PUT requests.",
+        examples=[
+            ["GET", "/thirdparties", "OKgV53jdbT1p1tKuZrB05eK9z0p9I2YX", ""],
+            ["POST", "/products", "OKgV53jdbT1p1tKuZrB05eK9z0p9I2YX", '{"ref": "PROD-007", "label": "New AI-Powered Gadget", "price": "199.99", "tva_tx": "20.0"}']
+        ]
+    )
+    
+    return demo
+
+# Main execution with better MCP server handling
+if __name__ == '__main__':
+    try:
+        demo = create_interface()
+        
+        logger.info("starting gradio app...")
+        demo.launch()
+            
+    except Exception as e:
+        logger.error(f"Failed to start application: {e}")
+        print(f"Error starting application: {e}")
+
+
+
+
+
+
+#----- Example usage ----
+# Uncomment these lines to test the API functionality directly
+
+# # Test basic API calling
+# print("Testing API connection...")
+# list_result = dolibarr_interface(method='GET', endpoint='/thirdparties')
+# print("Thirdparties list:", list_result)
+
+# # Test creating a product
+# new_product_data = {
+#     "ref": "PROD-007",
+#     "label": "New AI-Powered Gadget", 
+#     "price": "199.99",
+#     "tva_tx": "20.0"
+# }
+# create_result = dolibarr_interface(
+#     method='POST',
+#     endpoint='/products',
+#     payload_str=json.dumps(new_product_data)
+# )
+# print("Product creation result:", create_result)

doli4.py

@@ -0,0 +1,657 @@
+import gradio as gr
+import requests
+import json
+import asyncio
+import logging
+from typing import Dict, List, Any, Optional
+import anthropic
+import openai
+from datetime import datetime
+import os
+# from dotenv import load_dotenv
+
+# load_dotenv()
+def get_api_keys():
+    # Try to get from Hugging Face secrets first
+    openai_key = os.getenv("OPENAI_API_KEY")
+    dolibarr_key = os.getenv("DOLIBARR_API_KEY")
+    
+    # If not found, try to load from .env file (for local development)
+    if not openai_key or not dolibarr_key:
+        from dotenv import load_dotenv
+        load_dotenv()
+        openai_key = os.getenv("OPENAI_API_KEY")
+        dolibarr_key = os.getenv("DOLIBARR_API_KEY")
+    
+    return openai_key, dolibarr_key
+
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class DolibarrAPI:
+    """Your existing Dolibarr API class - keeping it unchanged"""
+    base_url = "https://valiant-trust-production.up.railway.app/api/index.php"
+    
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.headers = {
+            'DOLAPIKEY': api_key,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        }
+
+    def _request(self, method: str, endpoint: str, data: Optional[dict] = None, params: Optional[dict] = None) -> Any:
+        base_url = "https://valiant-trust-production.up.railway.app/api/index.php"
+        url = f"{base_url}{endpoint}"
+        
+        try:
+            response = requests.request(method, url, headers=self.headers, json=data, params=params)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            logger.error(f"API request failed: {e}")
+            return {"error": f"API request failed: {str(e)}"}
+        except json.JSONDecodeError as e:
+            logger.error(f"JSON decode error: {e}")
+            return {"error": f"Invalid JSON response: {str(e)}"}
+
+    def get_req(self, endpoint: str, params: Optional[dict] = None):
+        return self._request('GET', endpoint, params=params)
+
+    def post_req(self, endpoint: str, params: dict):
+        return self._request("POST", endpoint, data=params)
+
+    def put_req(self, endpoint: str, params: dict):
+        return self._request("PUT", endpoint, data=params)
+
+    def del_req(self, endpoint: str, params: Optional[dict] = None):
+        return self._request("DELETE", endpoint, params=params)
+
+def dolibarr_interface(method: str, endpoint: str, api_key=os.getenv("DOLIBARR_API_KEY"), payload_str: str = "") -> str:
+    """Your existing interface function - keeping it unchanged"""
+    try:
+        api = DolibarrAPI(api_key)
+        method = method.upper()
+        
+        payload = None
+        if payload_str and payload_str.strip():
+            try:
+                payload = json.loads(payload_str)
+            except json.JSONDecodeError as e:
+                return json.dumps({"error": f"Invalid JSON payload: {str(e)}"}, indent=2)
+
+        if method == 'GET':
+            result = api.get_req(endpoint, payload)
+        elif method == 'POST':
+            if not payload:
+                return json.dumps({"error": "POST requests require a payload"}, indent=2)
+            result = api.post_req(endpoint, payload)
+        elif method == 'PUT':
+            if not payload:
+                return json.dumps({"error": "PUT requests require a payload"}, indent=2)
+            result = api.put_req(endpoint, payload)
+        elif method == 'DELETE':
+            result = api.del_req(endpoint, payload)
+        else:
+            return json.dumps({"error": f"Invalid HTTP method '{method}' selected."}, indent=2)
+        
+        return json.dumps(result, indent=2)
+    
+    except Exception as e:
+        logger.error(f"Unexpected error in dolibarr_interface: {e}")
+        return json.dumps({"error": f"Unexpected error: {str(e)}"}, indent=2)
+
+class OpenAIDolibarrAgent:
+    def __init__(self, openai_api_key: str, dolibarr_api_key: str, base_url: str = None):
+        self.client = openai.OpenAI(api_key=openai_api_key, base_url=base_url)
+        self.dolibarr_api_key = dolibarr_api_key
+        
+        # System prompt with Dolibarr context
+        self.system_prompt = """You are a helpful ERP assistant that can interact with a Dolibarr system via API calls. 
+CRITICAL RULES:
+1. ALWAYS show ALL data returned by API calls - never truncate, limit, or summarize unless explicitly asked
+2. When listing items (customers, invoices, products), display EVERY record returned
+3. Present data in clean tables or structured format showing key fields
+4. If API returns 100+ records, show all unless user asks for specific filtering
+5. NEVER make assumptions about what the user wants to see - show everything
+5. DO NOT ASSUME DATA AS IF IT WAS RETURNED BY THE API, NEVER ASSUME
+        
+DOLIBARR API ENDPOINTS:
+- /thirdparties - GET: list all, GET /{id}: specific customer, POST: create
+- /invoices - GET: list all invoices, GET /{id}: specific invoice
+- /products - GET: list all products, POST: create product
+- /contacts - Contact management
+- /users - System users  
+- /proposals - Commercial proposals/quotes
+- /orders - Sales orders
+- /bills - Supplier bills
+- /projects - Project management
+- /stocks - Inventory management
+
+
+RESPONSE FORMAT RULES:
+- For lists: Show ID, Name, Status, and other key fields in table format
+- For single items: Show all relevant details clearly organized
+- Always extract and display the most important information from API responses
+- If API returns error, explain clearly what went wrong
+- Include record counts: "Found X customers:" or "Total invoices: Y"
+
+BEHAVIOR RULES:
+- Be proactive - if user asks for "customers", get ALL customers
+- Don't ask "would you like to see more?" - just show everything
+- For specific IDs, show complete details
+- When creating records, confirm success with details
+- Always make the API call needed - don't hesitate or ask for clarification
+
+Common operations:
+- GET /thirdparties - List all customers/suppliers
+- GET /thirdparties/{id} - Get specific customer details
+- POST /thirdparties - Create new customer
+- GET /invoices - List all invoices
+- GET /products - List all products
+- POST /products - Create new product
+
+You will use the following **HTTP methods**:
+
+* `GET` to retrieve data.
+* `POST` to create new records.
+* `PUT` to update existing records.
+* `DELETE` to delete records.
+
+Here is what you need to do for each of the provided **endpoints**:
+
+---
+
+### **1. `/thirdparties` (Customers, Suppliers, etc.)**
+
+#### **GET** (Retrieve a list or details of a third party):
+
+* **Endpoint**: `/thirdparties` or `/thirdparties/{id}`
+* **Required parameters for GET**: No parameters for listing all, but you can use `id` in the endpoint for details of a specific third party.
+* **Response**: A list of third parties or details of the specific one.
+
+#### **POST** (Create a new third party):
+
+* **Endpoint**: `/thirdparties`
+* **Required Parameters** (in `payload` JSON):
+
+  ```json
+  {
+    "name": "John Doe",          // The name of the third party
+    "address": "123 Main St",    // Street address
+    "zip": "12345",              // Postal code
+    "town": "Sample City",       // City or town
+    "country_id": 1,             // Country ID (e.g., 1 for USA)
+    "email": "johndoe@example.com", // Email address
+    "phone": "+1234567890",      // Phone number
+    "type": 1,                   // Type (1 for customer, 2 for supplier, etc.)
+    "status": 1                  // Status (1 for active, 0 for inactive)
+  }
+  ```
+
+#### **PUT** (Update an existing third party):
+
+* **Endpoint**: `/thirdparties/{id}`
+* **Required Parameters** (in `payload` JSON):
+
+  ```json
+  {
+    "name": "Updated Name",      // Update the name or other attributes as needed
+    "email": "newemail@example.com", // Update email
+    "phone": "+9876543210"       // Update phone number
+  }
+  ```
+
+#### **DELETE** (Delete a third party):
+
+* **Endpoint**: `/thirdparties/{id}`
+* **No payload is needed**, just the `id` of the third party to be deleted.
+
+---
+
+### **2. `/invoices`**
+
+#### **GET** (Retrieve a list or details of an invoice):
+
+* **Endpoint**: `/invoices` or `/invoices/{id}`
+* **Required parameters for GET**: None for listing all invoices, `id` for a specific invoice.
+* **Response**: A list of invoices or details of the specific invoice.
+
+#### **POST** (Create a new invoice):
+
+* **Endpoint**: `/invoices`
+* **Required Parameters** (in `payload` JSON):
+
+  ```json
+  {
+    "socid": 10,                 // Third-party ID (Customer ID)
+    "lines": [                   // List of invoice lines
+      {
+        "desc": "Web Development Service", // Description of the service/product
+        "subprice": 500,                // Unit price
+        "qty": 1,                       // Quantity
+        "total_ht": 500,                // Total excluding tax
+        "vat": 18,                      // VAT percentage
+        "total_ttc": 590                // Total including tax
+      }
+    ],
+    "date": "2025-06-01",            // Invoice creation date (YYYY-MM-DD)
+    "duedate": "2025-06-15"          // Due date (YYYY-MM-DD)
+  }
+  ```
+
+#### **PUT** (Update an existing invoice):
+
+* **Endpoint**: `/invoices/{id}`
+* **Required Parameters** (in `payload` JSON):
+
+  ```json
+  {
+    "lines": [                      // Updated lines
+      {
+        "desc": "Updated Service",    // New or updated description
+        "subprice": 550,              // New price
+        "qty": 2,                     // Updated quantity
+        "total_ht": 1100,             // Updated total excluding tax
+        "vat": 18,                    // VAT
+        "total_ttc": 1294             // Updated total including tax
+      }
+    ]
+  }
+  ```
+
+#### **DELETE** (Delete an invoice):
+
+* **Endpoint**: `/invoices/{id}`
+* **No payload needed**, just the `id` of the invoice to delete.
+
+---
+
+### **3. `/contacts` (Contacts for Third Parties)**
+
+#### **GET** (Retrieve a list or details of a contact):
+
+* **Endpoint**: `/contacts` or `/contacts/{id}`
+* **Required parameters for GET**: None for listing all contacts, `id` for a specific contact.
+* **Response**: A list of contacts or details of a specific contact.
+
+#### **POST** (Create a new contact):
+
+* **Endpoint**: `/contacts`
+* **Required Parameters** (in `payload` JSON):
+
+  ```json
+  {
+    "thirdparty_id": 1,              // Third-party ID (Customer or Supplier)
+    "firstname": "Jane",             // Contact first name
+    "lastname": "Doe",               // Contact last name
+    "email": "janedoe@example.com",  // Email address
+    "phone": "+1234567890",          // Phone number
+    "position": "Sales Manager",     // Position of the contact
+    "address": "1234 Office St"      // Address
+  }
+  ```
+
+#### **PUT** (Update an existing contact):
+
+* **Endpoint**: `/contacts/{id}`
+* **Required Parameters** (in `payload` JSON):
+
+  ```json
+  {
+    "email": "newemail@example.com", // Update email
+    "phone": "+9876543210"           // Update phone
+  }
+  ```
+
+#### **DELETE** (Delete a contact):
+
+* **Endpoint**: `/contacts/{id}`
+* **No payload needed**, just the `id` of the contact to delete.
+
+---
+
+### **4. `/orders` (Customer/Supplier Orders)**
+
+#### **GET** (Retrieve a list or details of an order):
+
+* **Endpoint**: `/orders` or `/orders/{id}`
+* **Required parameters for GET**: None for listing all orders, `id` for a specific order.
+* **Response**: A list of orders or details of a specific order.
+
+#### **POST** (Create a new order):
+
+* **Endpoint**: `/orders`
+* **Required Parameters** (in `payload` JSON):
+
+  ```json
+  {
+    "socid": 10,                    // Third-party ID (Customer ID)
+    "lines": [                       // List of order lines
+      {
+        "desc": "Laptop",            // Description of product
+        "subprice": 1000,            // Unit price
+        "qty": 1,                    // Quantity
+        "total_ht": 1000,            // Total excluding tax
+        "vat": 18,                   // VAT
+        "total_ttc": 1180            // Total including tax
+      }
+    ],
+    "date": "2025-06-01",             // Order date
+    "duedate": "2025-06-15"           // Due date
+  }
+  ```
+
+#### **PUT** (Update an existing order):
+
+* **Endpoint**: `/orders/{id}`
+* **Required Parameters** (in `payload` JSON):
+
+  ```json
+  {
+    "lines": [                       // Updated lines
+      {
+        "desc": "Updated Laptop",     // Updated description
+        "subprice": 1100,             // Updated price
+        "qty": 2,                     // Updated quantity
+        "total_ht": 2200,             // Updated total excluding tax
+        "vat": 18,                    // VAT
+        "total_ttc": 2600             // Updated total including tax
+      }
+    ]
+  }
+  ```
+
+#### **DELETE** (Delete an order):
+
+* **Endpoint**: `/orders/{id}`
+* **No payload needed**, just the `id` of the order to delete.
+
+---
+
+### **5. `/products`**
+
+#### **GET** (Retrieve a list or details of a product):
+
+* **Endpoint**: `/products` or `/products/{id}`
+* **Required parameters for GET**: None for listing all products, `id` for a specific product.
+* **Response**: A list of products or details of a specific product.
+
+#### **POST** (Create a new product):
+
+* **Endpoint**: `/products`
+* **Required Parameters** (in `payload` JSON):
+
+  ```json
+  {
+    "label": "Smartphone",           // Product
+  ```
+
+
+name
+"price": 499.99,                 // Unit price
+"stock": 100,                    // Quantity in stock
+"description": "Latest model",   // Product description
+"socid": 10                      // Supplier ID
+}
+
+
+#### **PUT** (Update an existing product):
+
+* **Endpoint**: `/products/{id}`
+* **Required Parameters** (in `payload` JSON):
+
+  ```json
+  {
+    "label": "Updated Smartphone",   // Updated product name
+    "price": 549.99,                 // Updated price
+    "stock": 120,                    // Updated stock
+    "description": "Updated model"   // Updated description
+  }
+  ```
+
+#### **DELETE** (Delete a product):
+
+* **Endpoint**: `/products/{id}`
+* **No payload needed**, just the `id` of the product to delete.
+
+# When a product/invoice/thirdparty is mentioned, call api with a get request to get their id and name and then proceed to make the next required api call.
+
+When users ask for information, determine the appropriate API call needed and use the dolibarr_api function.
+Always format responses in a user-friendly way, extracting key information from the API responses.
+If an API call fails, explain the error clearly and suggest alternatives.
+
+Current date: """ + datetime.now().strftime("%Y-%m-%d")
+
+        # Function definition for OpenAI format
+        self.functions = [
+            {
+                "name": "dolibarr_api",
+                "description": "Execute API calls to the Dolibarr ERP system",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "method": {
+                            "type": "string",
+                            "enum": ["GET", "POST", "PUT", "DELETE"],
+                            "description": "HTTP method for the API call"
+                        },
+                        "endpoint": {
+                            "type": "string", 
+                            "description": "API endpoint (e.g., /thirdparties, /invoices)"
+                        },
+                        "payload": {
+                            "type": "string",
+                            "description": "JSON payload for POST/PUT requests (leave empty for GET)"
+                        }
+                    },
+                    "required": ["method", "endpoint"]
+                }
+            }
+        ]
+
+    def execute_dolibarr_call(self, method: str, endpoint: str, payload: str = "") -> str:
+        """Execute the actual Dolibarr API call"""
+        return dolibarr_interface(method, endpoint, self.dolibarr_api_key, payload)
+
+    def chat(self, message: str, history: List[List[str]]) -> str:
+        """Main chat function that processes user messages"""
+        try:
+            # Convert Gradio history to OpenAI format
+            messages = [{"role": "system", "content": self.system_prompt}]
+            
+            for human_msg, assistant_msg in history:
+                if human_msg:
+                    messages.append({"role": "user", "content": human_msg})
+                if assistant_msg:
+                    messages.append({"role": "assistant", "content": assistant_msg})
+            
+            # Add current message
+            messages.append({"role": "user", "content": message})
+
+            # Call OpenAI API with functions
+            logger.info("Sending request to Nebius API...")
+            response = self.client.chat.completions.create(
+                model="gpt-3.5-turbo",  # or gpt-4 "Qwen/Qwen3-235B-A22B",
+                messages=messages,
+                functions=self.functions,
+                function_call="auto",
+                max_tokens=1500
+            )
+
+            # Process the response
+            message = response.choices[0].message
+            logger.info(f"Received response from Nebius: {message}")
+            
+            if message.function_call:
+                # Execute the Dolibarr API call
+                function_name = message.function_call.name
+                function_args = json.loads(message.function_call.arguments)
+                logger.info(f"Function call: {function_name} with args: {function_args}")
+                
+                if function_name == "dolibarr_api":
+                    api_result = self.execute_dolibarr_call(
+                        method=function_args.get("method", "GET"),
+                        endpoint=function_args.get("endpoint", ""),
+                        payload=function_args.get("payload", "")
+                    )
+                    logger.info(f"Dolibarr API result: {api_result}")
+                    # Send function result back to OpenAI
+                    messages.append({
+                        "role": "assistant",
+                        "content": None,
+                        "function_call": message.function_call
+                    })
+                    messages.append({
+                        "role": "function",
+                        "name": function_name,
+                        "content": api_result
+                    })
+                    
+                    # Get final response
+                    logger.info("Getting final response from Nebius...")
+                    final_response = self.client.chat.completions.create(
+                        model="gpt-3.5-turbo",#"Qwen/Qwen3-235B-A22B",
+                        messages=messages,
+                        max_tokens=1500
+                    )
+                    logger.info(f"Final response: {final_response.choices[0].message}")
+                    
+                    # Clean up the response content
+                    content = final_response.choices[0].message.content
+                    # Remove the <think> sections
+                    content = content.split('</think>')[-1].strip() if '</think>' in content else content
+                    return content
+            
+            # Clean up the response content for non-function calls too
+            content = message.content
+            content = content.split('</think>')[-1].strip() if '</think>' in content else content
+            return content if content else "I couldn't process that request."
+            
+        except Exception as e:
+            logger.error(f"Error in chat: {e}")
+            return f"Sorry, I encountered an error: {str(e)}"
+
+def create_openai_agent_interface():
+    """Create the Gradio interface for the OpenAI-powered Dolibarr agent"""
+    
+    # OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")  # Replace with your key
+    # NEBIUS_BASE_URL = "https://api.studio.nebius.ai/v1"  # For Nebius (optional)
+    # DOLIBARR_API_KEY = os.getenv("DOLIBARR_API_KEY")
+    
+    OPENAI_API_KEY, DOLIBARR_API_KEY = get_api_keys()
+    
+    if not OPENAI_API_KEY or not DOLIBARR_API_KEY:
+        raise ValueError("API keys not found. Please set them in Hugging Face Secrets or .env file")
+    
+    # Initialize the agent
+    agent = OpenAIDolibarrAgent(OPENAI_API_KEY, DOLIBARR_API_KEY)
+    agent = OpenAIDolibarrAgent(OPENAI_API_KEY, DOLIBARR_API_KEY)
+    #agent = OpenAIDolibarrAgent(os.getenv("NEBIUS_API_KEY"), DOLIBARR_API_KEY, NEBIUS_BASE_URL)  # For Nebius
+    
+    # Create Gradio ChatInterface
+    demo = gr.ChatInterface(
+        fn=agent.chat,
+        title="🤖 ERP Assistant",
+        description="""
+            # 🤖 AI-Powered Dolibarr ERP Assistant
+
+            Welcome to your intelligent business management assistant! I can help you manage your entire business operations through natural conversation.
+---
+            ## 🎯 What I Can Do:
+
+            ### 📋 Business Information
+            - List all customers and suppliers
+            - View detailed customer profiles
+            - Track invoice status
+            - Monitor product inventory
+            - Check order status
+
+            ### 👥 Customer Management
+            - Create new customers
+            - Update customer information
+            - Manage customer contacts
+            - Track customer orders
+
+            ### 💰 Financial Operations
+            - Create and manage invoices
+            - Track payment status
+            - Generate financial reports
+            - Monitor outstanding payments
+
+            ### 📦 Product Management
+            - View product catalog
+            - Update product information
+            - Track inventory levels
+            - Manage product categories
+
+            ### 📝 Order Processing
+            - Create new orders
+            - Track order status
+            - Manage order details
+            - Process order updates
+---
+            ## 🚀 Getting Started
+            1. Simply type your request in natural language
+            2. I'll understand and execute the appropriate actions
+            3. Get instant results in a clear, organized format
+---
+            ## 💡 Example Queries:
+            - "Show me all customers"
+            - "Create a new invoice for customer ID 1"
+            - "What's the status of order #123?"
+            - "List all products in stock"
+            - "Show me recent proposals"
+---
+            ## 🔧 Demo Instance
+            Try it out with our demo Dolibarr instance:
+            - URL: https://valiant-trust-production.up.railway.app/
+            - Username: admin
+            - Password: admin123
+
+            Just ask me anything about your business operations, and I'll help you manage them efficiently!
+            """,
+        examples=[
+            "Show me all customers",
+            "List all invoices", 
+            "What products do we have?",
+            "Get details for customer ID 1",
+            "Show me recent proposals"
+        ],
+        cache_examples=False,
+        theme=gr.themes.Soft()
+    )
+    
+    return demo
+
+# Main execution
+if __name__ == '__main__':
+    try:
+        print("🚀 Starting OpenAI-Powered Dolibarr Agent...")
+        
+        # Create and launch the interface
+        demo = create_openai_agent_interface()
+        demo.launch(
+            server_name="127.0.0.1",
+            server_port=7862,
+            share=False,
+            debug=True,
+            show_error=True
+        )
+        
+    except Exception as e:
+        logger.error(f"Failed to start application: {e}")
+        print(f"❌ Error starting application: {e}")
+
+# Example queries you can try:
+"""
+- "Show me all customers"
+- "List all invoices"
+- "Get me customer details for ID 1"  
+- "What products do we have?"
+- "Show me recent proposals"
+- "Create a new customer named Test Corp"
+- "Find all unpaid invoices"
+"""