cite-agent 1.0.4__py3-none-any.whl → 1.2.3__py3-none-any.whl

cite_agent/__init__.py

@@ -7,7 +7,7 @@ prior stacks preserved only in Git history, kept out of the runtime footprint.
 
 from .enhanced_ai_agent import EnhancedNocturnalAgent, ChatRequest, ChatResponse
 
-__version__ = "1.0.4"
+__version__ = "0.9.0b1"
 __author__ = "Nocturnal Archive Team"
 __email__ = "contact@nocturnal.dev"
 

cite_agent/account_client.py

@@ -63,28 +63,14 @@ class AccountClient:
         )
         self.timeout = timeout
 
-    def provision(self, email: str, password: str, is_new_user: bool = False) -> AccountCredentials:
-        """
-        Provision account credentials (login or register).
-
-        Args:
-            email: User email address
-            password: User password
-            is_new_user: True for registration, False for login
-
-        Returns:
-            AccountCredentials object
-
-        Raises:
-            AccountProvisioningError: If authentication fails
-        """
+    def provision(self, email: str, password: str) -> AccountCredentials:
         if self.base_url:
-            payload = self._request_credentials(email, password, is_new_user=is_new_user)
+            payload = self._request_credentials(email, password)
             return AccountCredentials.from_payload(email=email, payload=payload)
         return self._generate_offline_credentials(email, password)
 
     # -- internal helpers -------------------------------------------------
-    def _request_credentials(self, email: str, password: str, is_new_user: bool = False) -> Dict[str, Any]:
+    def _request_credentials(self, email: str, password: str) -> Dict[str, Any]:
         try:  # pragma: no cover - requires network
             import requests  # type: ignore
         except Exception as exc:  # pragma: no cover - executed when requests missing
@@ -92,42 +78,29 @@ class AccountClient:
                 "The 'requests' package is required for control-plane authentication"
             ) from exc
 
-        # Choose endpoint based on is_new_user flag
-        if is_new_user:
-            endpoint = self.base_url.rstrip("/") + "/api/auth/register"
-            operation = "registration"
-        else:
-            endpoint = self.base_url.rstrip("/") + "/api/auth/login"
-            operation = "login"
-
+        # Try login first
+        login_endpoint = self.base_url.rstrip("/") + "/api/auth/login"
         body = {"email": email, "password": password}
 
         try:
-            response = requests.post(endpoint, json=body, timeout=self.timeout)
+            response = requests.post(login_endpoint, json=body, timeout=self.timeout)
         except Exception as exc:  # pragma: no cover - network failure
-            raise AccountProvisioningError(f"Failed to reach control plane for {operation}") from exc
+            raise AccountProvisioningError("Failed to reach control plane") from exc
 
-        # Handle errors
+        # If login fails with 401 (user doesn't exist), try registration
+        if response.status_code == 401:
+            register_endpoint = self.base_url.rstrip("/") + "/api/auth/register"
+            try:
+                response = requests.post(register_endpoint, json=body, timeout=self.timeout)
+            except Exception as exc:
+                raise AccountProvisioningError("Failed to register account") from exc
+
+        # If still failing, raise error
         if response.status_code >= 400:
             detail = self._extract_error_detail(response)
-
-            # Provide helpful error messages
-            if response.status_code == 401 and not is_new_user:
-                raise AccountProvisioningError(
-                    f"Login failed: Invalid email or password. If you're a new user, please register first."
-                )
-            elif response.status_code == 409:
-                raise AccountProvisioningError(
-                    f"Registration failed: This email is already registered. Please log in instead."
-                )
-            elif response.status_code == 400 and "academic" in detail.lower():
-                raise AccountProvisioningError(
-                    f"Registration requires an academic email address (.edu, .ac.uk, etc.)"
-                )
-            else:
-                raise AccountProvisioningError(
-                    f"{operation.capitalize()} failed (status {response.status_code}): {detail}"
-                )
+            raise AccountProvisioningError(
+                f"Authentication failed (status {response.status_code}): {detail}"
+            )
 
         try:
             payload = response.json()

cite_agent/agent_backend_only.py

@@ -24,6 +24,7 @@ class ChatResponse:
     tools_used: list = None
     model: str = "backend"
     timestamp: str = None
+    tokens_used: int = 0
 
     def __post_init__(self):
         if self.timestamp is None:
@@ -45,6 +46,7 @@ class EnhancedNocturnalAgent:
             or "https://cite-agent-api-720dfadd602c.herokuapp.com"
         )
         self.auth_token = None
+        self.daily_token_usage = 0
         self._load_auth()
 
     def _load_auth(self):
@@ -66,10 +68,8 @@ class EnhancedNocturnalAgent:
     async def initialize(self):
         """Initialize agent"""
         if not self.auth_token:
-            raise RuntimeError(
-                "Not authenticated. Please run 'cite-agent --setup' first."
-            )
-        print(f"✅ Connected to backend: {self.backend_url}")
+            return False
+        return True
 
     async def chat(self, request: ChatRequest) -> ChatResponse:
         """
@@ -170,3 +170,29 @@ class EnhancedNocturnalAgent:
             "tokens_remaining": data.get("tokens_remaining", 0),
             "daily_limit": 25000,
         }
+
+    async def process_request(self, request: ChatRequest) -> ChatResponse:
+        """Process request (alias for chat method for CLI compatibility)"""
+        return await self.chat(request)
+
+    def get_usage_stats(self) -> Dict[str, Any]:
+        """Get usage statistics for CLI display"""
+        try:
+            quota = self.check_quota()
+            tokens_used = quota.get("tokens_used", 0)
+            daily_limit = quota.get("daily_limit", 50000)
+            usage_pct = (tokens_used / daily_limit * 100) if daily_limit > 0 else 0
+
+            return {
+                "daily_tokens_used": tokens_used,
+                "daily_token_limit": daily_limit,
+                "usage_percentage": usage_pct,
+                "tokens_remaining": quota.get("tokens_remaining", 0)
+            }
+        except Exception:
+            return {
+                "daily_tokens_used": 0,
+                "daily_token_limit": 50000,
+                "usage_percentage": 0,
+                "tokens_remaining": 50000
+            }