pyindus 0.1.0__py3-none-any.whl

pyindus/__init__.py

@@ -0,0 +1,37 @@
+"""PyIndus - Python package for Indus Chat API by Sarvam AI."""
+
+from pyindus.client import IndusClient
+from pyindus.auth import IndusAuth
+from pyindus.models import (
+    UserInfo,
+    ChatAccount,
+    TaskGraph,
+    ChatSession,
+    PromptResponse,
+    Step,
+    Config,
+)
+from pyindus.exceptions import (
+    IndusError,
+    AuthenticationError,
+    SessionError,
+    APIError,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "IndusClient",
+    "IndusAuth",
+    "UserInfo",
+    "ChatAccount",
+    "TaskGraph",
+    "ChatSession",
+    "PromptResponse",
+    "Step",
+    "Config",
+    "IndusError",
+    "AuthenticationError",
+    "SessionError",
+    "APIError",
+]

pyindus/auth.py

@@ -0,0 +1,405 @@
+"""Authentication module for Indus API.
+
+Handles the Ory/Kratos-based login flow:
+1. Initiate login flow → get flow ID and CSRF token
+2. Submit phone number → triggers OTP via SMS
+3. Submit OTP code → completes login, receives session cookies
+4. Refresh Indus auth token using session cookies
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from urllib.parse import urlencode, urlparse, parse_qs
+
+import httpx
+
+from pyindus.exceptions import AuthenticationError, APIError
+from pyindus.models import UserInfo, RefreshResponse
+
+logger = logging.getLogger(__name__)
+
+INDUS_BASE_URL = "https://indus.sarvam.ai"
+LOGIN_BASE_URL = "https://login.sarvam.ai"
+
+
+class IndusAuth:
+    """Handles authentication with the Indus platform.
+
+    The Indus platform uses Ory/Kratos for identity management with
+    phone number + OTP authentication. Session state is maintained
+    via cookies.
+    """
+
+    def __init__(self, http_client: httpx.Client | None = None):
+        self._client = http_client or httpx.Client(
+            follow_redirects=False,
+            timeout=30.0,
+            headers={
+                "user-agent": (
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) "
+                    "Chrome/144.0.0.0 Safari/537.36"
+                ),
+                "accept": "*/*",
+                "accept-language": "en-US,en;q=0.9",
+            },
+        )
+        self._owns_client = http_client is None
+        self._flow_id: str | None = None
+        self._csrf_token: str | None = None
+        self._phone: str | None = None
+        self._authenticated = False
+
+    @property
+    def client(self) -> httpx.Client:
+        """The underlying HTTP client (shares cookies across auth and chat)."""
+        return self._client
+
+    @property
+    def is_authenticated(self) -> bool:
+        return self._authenticated
+
+    def login(self, phone: str) -> str:
+        """Initiate login flow with phone number.
+
+        Args:
+            phone: Phone number with country code (e.g., "+918874163264")
+
+        Returns:
+            Flow ID for the login flow.
+
+        Raises:
+            AuthenticationError: If the login flow fails.
+        """
+        self._phone = phone
+
+        # Step 1: Create a new login flow
+        logger.info("Creating login flow...")
+        resp = self._client.post(
+            f"{LOGIN_BASE_URL}/api/flow/login",
+            json={"returnTo": INDUS_BASE_URL},
+        )
+        if resp.status_code != 200:
+            raise AuthenticationError(
+                f"Failed to create login flow: {resp.status_code} {resp.text}"
+            )
+        flow_data = resp.json()
+        self._flow_id = flow_data.get("id")
+        if not self._flow_id:
+            raise AuthenticationError(
+                f"No flow ID in login response: {flow_data}"
+            )
+
+        # Now fetch the actual flow data to get the CSRF token
+        self._refresh_csrf_token()
+        if not self._csrf_token:
+            raise AuthenticationError("Could not extract CSRF token from flow.")
+        
+        logger.info("Login flow created: %s", self._flow_id)
+
+        # Step 2: Submit phone number to trigger OTP
+        logger.info("Submitting phone number to trigger OTP...")
+        form_data = {
+            "csrf_token": self._csrf_token,
+            "method": "code",
+            "identifier": phone,
+        }
+        resp = self._client.post(
+            f"{LOGIN_BASE_URL}/identity/self-service/login",
+            params={"flow": self._flow_id},
+            content=urlencode(form_data),
+            headers={"content-type": "application/x-www-form-urlencoded"},
+        )
+
+        # Expect a 303 redirect (OTP sent) or 422 (validation error) or 200
+        if resp.status_code == 303:
+            location = resp.headers.get("location", "")
+            if "error" in location:
+                raise AuthenticationError(f"Login failed: Redirected to error page ({location})")
+            logger.info("OTP sent successfully. Waiting for code...")
+        elif resp.status_code in (200, 422):
+            # Check if there's an error in the response
+            try:
+                body = resp.json()
+                if "error" in body:
+                    raise AuthenticationError(
+                        f"Login error: {body['error']}"
+                    )
+            except (json.JSONDecodeError, KeyError):
+                pass
+            logger.info("OTP sent (status %d). Waiting for code...", resp.status_code)
+        else:
+            raise AuthenticationError(
+                f"Failed to submit phone: {resp.status_code} {resp.text}"
+            )
+
+        # Step 3: Refresh CSRF token from updated flow
+        self._refresh_csrf_token()
+
+        return self._flow_id
+
+    def verify_otp(self, code: str) -> UserInfo:
+        """Submit OTP code to complete login.
+
+        Args:
+            code: The OTP code received via SMS.
+
+        Returns:
+            UserInfo for the authenticated user.
+
+        Raises:
+            AuthenticationError: If OTP verification fails.
+        """
+        if not self._flow_id or not self._csrf_token or not self._phone:
+            raise AuthenticationError(
+                "Must call login() before verify_otp()"
+            )
+
+        logger.info("Submitting OTP code...")
+        form_data = {
+            "csrf_token": self._csrf_token,
+            "method": "code",
+            "identifier": self._phone,
+            "code": code,
+        }
+        resp = self._client.post(
+            f"{LOGIN_BASE_URL}/identity/self-service/login",
+            params={"flow": self._flow_id},
+            content=urlencode(form_data),
+            headers={"content-type": "application/x-www-form-urlencoded"},
+        )
+
+        if resp.status_code == 303:
+            # Follow the redirect to indus.sarvam.ai to set cookies
+            location = resp.headers.get("location", "")
+            if "error" in location:
+                raise AuthenticationError(f"OTP verification failed: Redirected to error page ({location})")
+            logger.info("Login successful, following redirect to: %s", location)
+            if location:
+                # Follow redirect — this sets the session cookies on indus.sarvam.ai
+                self._client.get(location)
+        elif resp.status_code == 200:
+            # Might have the session inline
+            try:
+                body = resp.json()
+                if "error" in body:
+                    raise AuthenticationError(
+                        f"OTP verification failed: {body['error']}"
+                    )
+            except (json.JSONDecodeError, KeyError):
+                pass
+        elif resp.status_code == 422:
+            try:
+                body = resp.json()
+                error_msg = self._extract_error_message(body)
+                raise AuthenticationError(
+                    f"OTP verification failed: {error_msg}"
+                )
+            except (json.JSONDecodeError, KeyError):
+                raise AuthenticationError(
+                    f"OTP verification failed: {resp.status_code} {resp.text}"
+                )
+        else:
+            raise AuthenticationError(
+                f"OTP verification failed: {resp.status_code} {resp.text}"
+            )
+
+        # Step 4: Refresh the Indus auth token
+        self.refresh()
+
+        # Step 5: Get user info
+        user_info = self.get_me()
+        self._authenticated = True
+        logger.info("Authenticated as: %s", user_info.name)
+        return user_info
+
+    def refresh(self) -> RefreshResponse:
+        """Refresh the Indus auth token.
+
+        Returns:
+            RefreshResponse with token expiry info.
+
+        Raises:
+            AuthenticationError: If token refresh fails.
+        """
+        logger.debug("Refreshing auth token...")
+        resp = self._client.post(
+            f"{INDUS_BASE_URL}/api/auth/refresh",
+            headers={"origin": INDUS_BASE_URL, "referer": f"{INDUS_BASE_URL}/"},
+        )
+
+        if resp.status_code == 401:
+            self._authenticated = False
+            raise AuthenticationError("Session expired. Please login again.")
+
+        if resp.status_code != 200:
+            raise APIError(
+                f"Token refresh failed: {resp.status_code}",
+                status_code=resp.status_code,
+                response_body=resp.text,
+            )
+
+        data = resp.json()
+        result = RefreshResponse.model_validate(data)
+        self._authenticated = True
+        logger.debug("Token refreshed, expires in %ds", result.expires_in)
+        return result
+
+    def get_me(self) -> UserInfo:
+        """Get current user info.
+
+        Returns:
+            UserInfo for the authenticated user.
+
+        Raises:
+            AuthenticationError: If not authenticated.
+        """
+        resp = self._client.get(
+            f"{INDUS_BASE_URL}/api/auth/me",
+            headers={"referer": f"{INDUS_BASE_URL}/"},
+        )
+
+        if resp.status_code == 401:
+            self._authenticated = False
+            raise AuthenticationError("Not authenticated")
+
+        if resp.status_code != 200:
+            raise APIError(
+                f"Failed to get user info: {resp.status_code}",
+                status_code=resp.status_code,
+                response_body=resp.text,
+            )
+
+        data = resp.json()
+        return UserInfo.model_validate(data)
+
+    def save_session(self, path: str | Path) -> None:
+        """Save session cookies to a file for later reuse.
+
+        Args:
+            path: File path to save the session data.
+        """
+        path = Path(path)
+        cookies_data = []
+        for cookie in self._client.cookies.jar:
+            cookies_data.append({
+                "name": cookie.name,
+                "value": cookie.value,
+                "domain": cookie.domain,
+                "path": cookie.path,
+            })
+
+        session_data = {
+            "cookies": cookies_data,
+            "authenticated": self._authenticated,
+        }
+        path.write_text(json.dumps(session_data, indent=2))
+        logger.info("Session saved to %s", path)
+
+    def load_session(self, path: str | Path) -> bool:
+        """Load session cookies from a file.
+
+        Args:
+            path: File path to load the session data from.
+
+        Returns:
+            True if session was loaded and is valid.
+
+        Raises:
+            AuthenticationError: If session file doesn't exist or is invalid.
+        """
+        path = Path(path)
+        if not path.exists():
+            raise AuthenticationError(f"Session file not found: {path}")
+
+        try:
+            session_data = json.loads(path.read_text())
+        except (json.JSONDecodeError, OSError) as e:
+            raise AuthenticationError(f"Failed to load session: {e}")
+
+        # Restore cookies
+        for cookie_data in session_data.get("cookies", []):
+            self._client.cookies.set(
+                cookie_data["name"],
+                cookie_data["value"],
+                domain=cookie_data.get("domain", ""),
+                path=cookie_data.get("path", "/"),
+            )
+
+        # Verify the session is still valid
+        try:
+            self.refresh()
+            self._authenticated = True
+            logger.info("Session loaded and validated from %s", path)
+            return True
+        except (AuthenticationError, APIError):
+            self._authenticated = False
+            logger.warning("Loaded session is expired")
+            return False
+
+    def close(self) -> None:
+        """Close the HTTP client if we own it."""
+        if self._owns_client:
+            self._client.close()
+
+    def _refresh_csrf_token(self) -> None:
+        """Fetch the latest CSRF token from the login flow."""
+        if not self._flow_id:
+            return
+
+        resp = self._client.get(
+            f"{LOGIN_BASE_URL}/api/flow/login",
+            params={"id": self._flow_id},
+        )
+        if resp.status_code == 200:
+            flow_data = resp.json()
+            token = self._extract_csrf_token(flow_data)
+            if token:
+                self._csrf_token = token
+                logger.debug("CSRF token refreshed")
+
+    @staticmethod
+    def _extract_csrf_token(flow_data: dict) -> str | None:
+        """Extract CSRF token from Ory/Kratos flow data.
+
+        The CSRF token is nested in the UI nodes of the flow response.
+        """
+        # Try direct csrf_token field
+        if "csrf_token" in flow_data:
+            return flow_data["csrf_token"]
+
+        # Try nested in UI nodes (Ory/Kratos format)
+        ui = flow_data.get("ui", {})
+        nodes = ui.get("nodes", [])
+        for node in nodes:
+            attrs = node.get("attributes", {})
+            if attrs.get("name") == "csrf_token":
+                return attrs.get("value")
+
+        # Try in the flow's action URL
+        return None
+
+    @staticmethod
+    def _extract_error_message(body: dict) -> str:
+        """Extract a human-readable error from an Ory/Kratos error response."""
+        # Check UI messages
+        ui = body.get("ui", {})
+        messages = ui.get("messages", [])
+        if messages:
+            return "; ".join(m.get("text", str(m)) for m in messages)
+
+        # Check node-level messages
+        nodes = ui.get("nodes", [])
+        for node in nodes:
+            node_messages = node.get("messages", [])
+            if node_messages:
+                return "; ".join(m.get("text", str(m)) for m in node_messages)
+
+        # Check top-level error
+        error = body.get("error", {})
+        if isinstance(error, dict):
+            return error.get("message", str(error))
+        return str(error)

pyindus/chat.py

@@ -0,0 +1,213 @@
+"""Chat operations module for Indus API.
+
+Handles chat sessions, prompts, task graphs, and account operations.
+"""
+
+from __future__ import annotations
+
+import logging
+import uuid
+
+import httpx
+
+from pyindus.exceptions import APIError, AuthenticationError, SessionError
+from pyindus.models import (
+    ChatAccount,
+    ChatSession,
+    Config,
+    PromptResponse,
+    TaskGraph,
+)
+
+logger = logging.getLogger(__name__)
+
+INDUS_BASE_URL = "https://indus.sarvam.ai"
+
+
+class IndusChat:
+    """Handles chat operations with the Indus API.
+
+    This class requires an authenticated httpx.Client with valid
+    session cookies. Use IndusAuth to authenticate first.
+    """
+
+    def __init__(self, http_client: httpx.Client):
+        self._client = http_client
+
+    def get_task_graphs(self, online_only: bool = True) -> list[TaskGraph]:
+        """Get available AI models (task graphs).
+
+        Args:
+            online_only: If True, only return online/available models.
+
+        Returns:
+            List of available TaskGraph models.
+        """
+        params = {}
+        if online_only:
+            params["online"] = "true"
+
+        resp = self._request("GET", "/api/chat/task-graphs", params=params)
+        return [TaskGraph.model_validate(tg) for tg in resp.json()]
+
+    def get_task_graph(self, uid: str) -> TaskGraph:
+        """Get details of a specific task graph.
+
+        Args:
+            uid: The task graph UID.
+
+        Returns:
+            TaskGraph details.
+        """
+        resp = self._request("GET", f"/api/chat/task-graphs/{uid}")
+        return TaskGraph.model_validate(resp.json())
+
+    def create_session(self, task_graph_uid: str) -> str:
+        """Create a new chat session.
+
+        Args:
+            task_graph_uid: UID of the task graph (model) to use.
+
+        Returns:
+            The session UID.
+        """
+        resp = self._request(
+            "POST",
+            "/api/chat/session",
+            json={"task_graph_uid": task_graph_uid},
+        )
+
+        if resp.status_code != 201:
+            raise SessionError(
+                f"Failed to create session: {resp.status_code} {resp.text}"
+            )
+
+        session_uid = resp.json()
+        if isinstance(session_uid, str):
+            logger.info("Created session: %s", session_uid)
+            return session_uid
+        else:
+            # The response might be a dict with a uid field
+            uid = session_uid.get("uid", session_uid.get("id", str(session_uid)))
+            logger.info("Created session: %s", uid)
+            return uid
+
+    def send_prompt(self, session_uid: str, prompt: str) -> PromptResponse:
+        """Send a prompt to a chat session.
+
+        Args:
+            session_uid: The session UID.
+            prompt: The user's message.
+
+        Returns:
+            PromptResponse containing the AI's response steps.
+        """
+        # Generate trace ID for the request
+        trace_id = uuid.uuid4().hex[:32]
+
+        resp = self._request(
+            "POST",
+            "/api/chat/prompt/prompt",
+            json={
+                "sessionUid": session_uid,
+                "prompt": prompt,
+            },
+            extra_headers={
+                "x-amzn-trace-id": f"Root=1-{trace_id[:8]}-{trace_id[8:32]};eru={session_uid}",
+            },
+            timeout=120.0,  # Prompts can take longer
+        )
+
+        return PromptResponse.model_validate(resp.json())
+
+    def list_sessions(self, include_shares: bool = True) -> list[ChatSession]:
+        """List all chat sessions.
+
+        Args:
+            include_shares: If True, include shared sessions.
+
+        Returns:
+            List of ChatSession objects.
+        """
+        params = {}
+        if include_shares:
+            params["include_shares"] = "true"
+
+        resp = self._request("GET", "/api/chat/session", params=params)
+        return [ChatSession.model_validate(s) for s in resp.json()]
+
+    def get_account_me(self) -> ChatAccount:
+        """Get chat account info.
+
+        Returns:
+            ChatAccount with user details.
+        """
+        resp = self._request("GET", "/api/chat/account/me")
+        return ChatAccount.model_validate(resp.json())
+
+    def get_config(self) -> Config:
+        """Get platform configuration.
+
+        Returns:
+            Config with platform settings.
+        """
+        resp = self._request("GET", "/api/config")
+        return Config.model_validate(resp.json())
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict | None = None,
+        json: dict | None = None,
+        extra_headers: dict | None = None,
+        timeout: float | None = None,
+    ) -> httpx.Response:
+        """Make an authenticated request to the Indus API.
+
+        Args:
+            method: HTTP method.
+            path: API path (relative to INDUS_BASE_URL).
+            params: Query parameters.
+            json: JSON request body.
+            extra_headers: Additional headers.
+            timeout: Request timeout.
+
+        Returns:
+            httpx.Response
+
+        Raises:
+            AuthenticationError: If the request returns 401.
+            APIError: If the request fails.
+        """
+        url = f"{INDUS_BASE_URL}{path}"
+        headers = {
+            "accept": "application/json, text/plain, */*",
+            "origin": INDUS_BASE_URL,
+            "referer": f"{INDUS_BASE_URL}/",
+        }
+        if extra_headers:
+            headers.update(extra_headers)
+
+        kwargs: dict = {"headers": headers}
+        if params:
+            kwargs["params"] = params
+        if json is not None:
+            kwargs["json"] = json
+        if timeout:
+            kwargs["timeout"] = timeout
+
+        resp = self._client.request(method, url, **kwargs)
+
+        if resp.status_code == 401:
+            raise AuthenticationError("Not authenticated. Please login first.")
+
+        if resp.status_code >= 400:
+            raise APIError(
+                f"API error {resp.status_code}: {resp.text}",
+                status_code=resp.status_code,
+                response_body=resp.text,
+            )
+
+        return resp

pyindus/cli.py

@@ -0,0 +1,96 @@
+"""CLI entry point for PyIndus.
+
+Provides an interactive login flow.
+"""
+
+from __future__ import annotations
+
+import sys
+
+
+def main():
+    """Interactive login and chat."""
+    from pyindus.client import IndusClient
+
+    client = IndusClient()
+
+    print("╔══════════════════════════════════════╗")
+    print("║        PyIndus - Indus Chat          ║")
+    print("║     Powered by Sarvam AI             ║")
+    print("╚══════════════════════════════════════╝")
+    print()
+
+    # Try loading existing session
+    try:
+        if client.load_session():
+            user = client.get_user_info()
+            print(f"✓ Session loaded. Welcome back, {user.name}!")
+            _chat_loop(client)
+            return
+    except Exception:
+        pass
+
+    # Interactive login
+    phone = input("Enter your phone number (with country code, e.g., +91...): ").strip()
+    if not phone:
+        print("Phone number is required.")
+        sys.exit(1)
+
+    try:
+        client.login(phone)
+        print(f"✓ OTP sent to {phone}")
+    except Exception as e:
+        print(f"✗ Login failed: {e}")
+        sys.exit(1)
+
+    code = input("Enter the OTP code: ").strip()
+    if not code:
+        print("OTP code is required.")
+        sys.exit(1)
+
+    try:
+        user = client.verify_otp(code)
+        print(f"✓ Welcome, {user.name}!")
+        client.save_session()
+        print("✓ Session saved for next time.")
+    except Exception as e:
+        print(f"✗ OTP verification failed: {e}")
+        sys.exit(1)
+
+    _chat_loop(client)
+
+
+def _chat_loop(client):
+    """Simple interactive chat loop."""
+    print()
+    print("Type your message (or 'quit' to exit, 'new' for new session):")
+    print()
+
+    while True:
+        try:
+            prompt = input("You: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\nGoodbye!")
+            break
+
+        if not prompt:
+            continue
+        if prompt.lower() in ("quit", "exit", "q"):
+            print("Goodbye!")
+            break
+        if prompt.lower() == "new":
+            client.new_session()
+            print("✓ New session started.")
+            continue
+
+        try:
+            response = client.chat(prompt)
+            print(f"\nIndus: {response.answer}\n")
+        except Exception as e:
+            print(f"\n✗ Error: {e}\n")
+
+    client.close()
+
+
+if __name__ == "__main__":
+    main()

pyindus/client.py

@@ -0,0 +1,300 @@
+"""High-level client for the Indus Chat API.
+
+Combines auth and chat modules into a simple, user-friendly interface.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import httpx
+
+from pyindus.auth import IndusAuth
+from pyindus.chat import IndusChat
+from pyindus.exceptions import AuthenticationError, SessionError
+from pyindus.models import (
+    ChatAccount,
+    ChatSession,
+    Config,
+    PromptResponse,
+    TaskGraph,
+    UserInfo,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class IndusClient:
+    """High-level client for interacting with the Indus Chat API.
+
+    Usage::
+
+        # Interactive login
+        client = IndusClient()
+        client.login("+91XXXXXXXXXX")
+        client.verify_otp("123456")
+
+        # Chat
+        response = client.chat("What is AI?")
+        print(response.answer)
+
+        # Save session for later
+        client.save_session("session.json")
+
+    Usage with context manager::
+
+        with IndusClient() as client:
+            client.load_session("session.json")
+            response = client.chat("Hello!")
+            print(response.answer)
+    """
+
+    def __init__(self, session_file: str | Path = "indus_session.json"):
+        self.session_file = session_file
+        self._http_client = httpx.Client(
+            follow_redirects=False,
+            timeout=30.0,
+            headers={
+                "user-agent": (
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) "
+                    "Chrome/144.0.0.0 Safari/537.36"
+                ),
+                "accept": "*/*",
+                "accept-language": "en-US,en;q=0.9",
+            },
+        )
+        self._auth = IndusAuth(http_client=self._http_client)
+        self._chat = IndusChat(http_client=self._http_client)
+        self._default_task_graph_uid: str | None = None
+        self._current_session_uid: str | None = None
+        
+        # Auto-load session if it exists to make it feel like an SDK
+        try:
+            self.load_session(self.session_file, quiet=True)
+        except AuthenticationError:
+            pass
+
+    # ── Context Manager ──────────────────────────────────────────
+
+    def __enter__(self) -> IndusClient:
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.close()
+
+    # ── Authentication ───────────────────────────────────────────
+
+    def login(self, phone: str) -> str:
+        """Start login flow with phone number.
+
+        An OTP will be sent to the provided phone number via SMS.
+        Call verify_otp() with the received code to complete login.
+
+        Args:
+            phone: Phone number with country code (e.g., "+918874163264").
+
+        Returns:
+            Flow ID for the login flow.
+        """
+        return self._auth.login(phone)
+
+    def verify_otp(self, code: str) -> UserInfo:
+        """Complete login with OTP code.
+
+        Args:
+            code: The OTP code received via SMS.
+
+        Returns:
+            UserInfo for the authenticated user.
+        """
+        user_info = self._auth.verify_otp(code)
+
+        # Cache the default task graph
+        try:
+            models = self.get_models()
+            if models:
+                self._default_task_graph_uid = models[0].uid
+                logger.info("Default model: %s", models[0].name)
+        except Exception as e:
+            logger.warning("Could not fetch models: %s", e)
+
+        # Auto-save session to provide a seamless SDK experience
+        self.save_session(self.session_file)
+        return user_info
+
+    def save_session(self, path: str | Path | None = None) -> None:
+        """Save session cookies to disk for later reuse.
+
+        Args:
+            path: File path to save the session data. Uses the default if not provided.
+        """
+        self._auth.save_session(path or self.session_file)
+
+    def load_session(self, path: str | Path | None = None, quiet: bool = False) -> bool:
+        """Load a previously saved session.
+
+        Args:
+            path: File path to load the session data from. Uses the default if not provided.
+            quiet: If True, suppress errors if file doesn't exist.
+
+        Returns:
+            True if session loaded and is still valid.
+        """
+        try:
+            result = self._auth.load_session(path or self.session_file)
+        except AuthenticationError:
+            if quiet:
+                return False
+            raise
+
+        if result:
+            # Cache the default task graph
+            try:
+                models = self.get_models()
+                if models:
+                    self._default_task_graph_uid = models[0].uid
+            except Exception as e:
+                if not quiet:
+                    logger.warning("Could not fetch models: %s", e)
+
+        return result
+
+    @property
+    def is_authenticated(self) -> bool:
+        """Whether the client is currently authenticated."""
+        return self._auth.is_authenticated
+
+    def get_user_info(self) -> UserInfo:
+        """Get current user info.
+
+        Returns:
+            UserInfo for the authenticated user.
+        """
+        return self._auth.get_me()
+
+    def refresh_auth(self):
+        """Manually refresh the auth token."""
+        return self._auth.refresh()
+
+    # ── Chat ─────────────────────────────────────────────────────
+
+    def chat(
+        self,
+        prompt: str,
+        *,
+        session_uid: str | None = None,
+        task_graph_uid: str | None = None,
+    ) -> PromptResponse:
+        """Send a message and get a response.
+
+        If no session_uid is provided, a new session will be created.
+        If no task_graph_uid is provided, the default model is used.
+
+        Args:
+            prompt: The user message.
+            session_uid: Optional existing session UID for conversation continuity.
+            task_graph_uid: Optional task graph UID to specify which model to use.
+
+        Returns:
+            PromptResponse with the AI's response.
+        """
+        if not self._auth.is_authenticated:
+            # Try to auto-refresh if we have cookies but token expired
+            try:
+                self._auth.refresh()
+            except AuthenticationError:
+                raise AuthenticationError(
+                    "Not authenticated. Call login() and verify_otp() first."
+                )
+
+        # Auto-refresh proactively wrapped around the chat to handle expiration
+        # IndusChat already handles throwing APIErrors, but we can catch 401s
+        # and retry once if the token expired mid-session.
+
+        # Determine task graph
+        tg_uid = task_graph_uid or self._default_task_graph_uid
+        if not tg_uid:
+            models = self.get_models()
+            if not models:
+                raise SessionError("No models available")
+            tg_uid = models[0].uid
+            self._default_task_graph_uid = tg_uid
+
+        # Use existing session or create a new one
+        if session_uid:
+            sid = session_uid
+        elif self._current_session_uid:
+            sid = self._current_session_uid
+        else:
+            sid = self._chat.create_session(tg_uid)
+            self._current_session_uid = sid
+
+        # Send prompt with auto-retry on 401
+        try:
+            return self._chat.send_prompt(sid, prompt)
+        except AuthenticationError:
+            # Token might have expired just now, try to refresh and retry
+            logger.info("Session expired during chat. Attempting auto-refresh...")
+            self._auth.refresh()
+            # Save the newly refreshed session automatically
+            self.save_session()
+            return self._chat.send_prompt(sid, prompt)
+
+    def new_session(self, task_graph_uid: str | None = None) -> str:
+        """Create a new chat session explicitly.
+
+        Args:
+            task_graph_uid: Optional task graph UID. Uses default if not provided.
+
+        Returns:
+            The new session UID.
+        """
+        tg_uid = task_graph_uid or self._default_task_graph_uid
+        if not tg_uid:
+            models = self.get_models()
+            if not models:
+                raise SessionError("No models available")
+            tg_uid = models[0].uid
+
+        self._current_session_uid = self._chat.create_session(tg_uid)
+        return self._current_session_uid
+
+    def get_models(self) -> list[TaskGraph]:
+        """Get available AI models.
+
+        Returns:
+            List of available TaskGraph models.
+        """
+        return self._chat.get_task_graphs(online_only=True)
+
+    def list_sessions(self) -> list[ChatSession]:
+        """List all chat sessions.
+
+        Returns:
+            List of ChatSession objects.
+        """
+        return self._chat.list_sessions()
+
+    def get_account(self) -> ChatAccount:
+        """Get chat account info.
+
+        Returns:
+            ChatAccount with user details.
+        """
+        return self._chat.get_account_me()
+
+    def get_config(self) -> Config:
+        """Get platform configuration.
+
+        Returns:
+            Config with platform settings.
+        """
+        return self._chat.get_config()
+
+    # ── Cleanup ──────────────────────────────────────────────────
+
+    def close(self) -> None:
+        """Close the client and release resources."""
+        self._auth.close()

pyindus/exceptions.py

@@ -0,0 +1,28 @@
+"""Custom exceptions for PyIndus."""
+
+
+class IndusError(Exception):
+    """Base exception for all PyIndus errors."""
+
+    pass
+
+
+class AuthenticationError(IndusError):
+    """Raised when authentication fails."""
+
+    pass
+
+
+class SessionError(IndusError):
+    """Raised when session operations fail."""
+
+    pass
+
+
+class APIError(IndusError):
+    """Raised when an API call returns an unexpected error."""
+
+    def __init__(self, message: str, status_code: int | None = None, response_body: str | None = None):
+        self.status_code = status_code
+        self.response_body = response_body
+        super().__init__(message)

pyindus/models.py

@@ -0,0 +1,171 @@
+"""Pydantic models for Indus API responses."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class UserInfo(BaseModel):
+    """User info from /api/auth/me."""
+
+    sub: str
+    email: str = ""
+    name: str = ""
+    token_expires_at: int = Field(alias="tokenExpiresAt")
+    token_expires_in: int = Field(alias="tokenExpiresIn")
+
+    model_config = {"populate_by_name": True}
+
+
+class ChatAccount(BaseModel):
+    """Chat account info from /api/chat/account/me."""
+
+    uid: str
+    first_name: str | None = None
+    last_name: str | None = None
+    full_name: str | None = None
+    email: str = ""
+    dp: str | None = None
+
+
+class TaskGraph(BaseModel):
+    """Available AI model/task graph."""
+
+    uid: str
+    name: str
+    description: str = ""
+    online: bool = False
+    online_sort_order: int = 0
+    favicon_light: str | None = None
+    favicon_dark: str | None = None
+    nodes: dict | None = None
+    attachment_mime: list[str] = Field(default_factory=list, alias="attachmentMime")
+    max_attachment_count: int | None = Field(default=None, alias="maxAttachmentCount")
+    max_attachment_size: int | None = Field(default=None, alias="maxAttachmentSize")
+    prompt_improvement_agent_uid: str | None = Field(default=None, alias="prompt_improvement_agent_uid")
+    can_edit_artefact: bool = Field(default=False, alias="canEditArtefact")
+    init_json_schema: dict | None = Field(default=None, alias="initJsonSchema")
+
+    model_config = {"populate_by_name": True}
+
+
+class ChatSession(BaseModel):
+    """Chat session metadata."""
+
+    uid: str
+    title: str = ""
+    task_graph_uid: str = ""
+    task_graph_version: int | None = None
+    created_at: str = ""
+    role: str = ""
+
+
+class Step(BaseModel):
+    """Individual step in a prompt response.
+
+    Step types (determined by 't' field):
+        0  - Thinking/reasoning content
+        20 - Separator/newline
+        17 - Tool call (search, etc.)
+        15 - Tool result
+    """
+
+    node_uid: str | None = None
+    t: int = 0
+    content: str | None = None
+    # Tool call fields
+    id: str | None = None
+    name: str | None = None
+    arg: str | None = None
+    mcp_uid: str | None = None
+
+    @property
+    def is_thinking(self) -> bool:
+        return self.t == 0
+
+    @property
+    def is_tool_call(self) -> bool:
+        return self.t == 17
+
+    @property
+    def is_tool_result(self) -> bool:
+        return self.t == 15
+
+    @property
+    def is_separator(self) -> bool:
+        return self.t == 20
+
+
+class PromptResponse(BaseModel):
+    """Full response from /api/chat/prompt/prompt."""
+
+    human_turn_uid: str = Field(alias="humanTurnUid")
+    agent_turn_uid: str = Field(alias="agentTurnUid")
+    steps: list[Step] = Field(default_factory=list)
+
+    model_config = {"populate_by_name": True}
+
+    @property
+    def answer(self) -> str:
+        """Extract the final text answer from the steps.
+
+        The final answer is typically the last thinking step (t=0) that
+        contains the synthesized response after all tool calls.
+        """
+        answer_parts: list[str] = []
+        # Find the last group of thinking steps after tool results
+        last_tool_result_idx = -1
+        for i, step in enumerate(self.steps):
+            if step.is_tool_result:
+                last_tool_result_idx = i
+
+        # Collect all thinking content after the last tool result
+        start_idx = last_tool_result_idx + 1 if last_tool_result_idx >= 0 else 0
+        for step in self.steps[start_idx:]:
+            if step.is_thinking and step.content:
+                answer_parts.append(step.content)
+            elif step.is_separator and step.content:
+                answer_parts.append(step.content)
+
+        return "".join(answer_parts).strip()
+
+    @property
+    def thinking(self) -> str:
+        """Extract thinking/reasoning content (before the final answer)."""
+        parts: list[str] = []
+        for step in self.steps:
+            if step.is_thinking and step.content:
+                parts.append(step.content)
+            elif step.is_tool_call:
+                break  # Stop at first tool call
+        return "".join(parts).strip()
+
+    @property
+    def tool_calls(self) -> list[Step]:
+        """Get all tool call steps."""
+        return [s for s in self.steps if s.is_tool_call]
+
+    @property
+    def tool_results(self) -> list[Step]:
+        """Get all tool result steps."""
+        return [s for s in self.steps if s.is_tool_result]
+
+
+class RefreshResponse(BaseModel):
+    """Response from /api/auth/refresh."""
+
+    success: bool
+    expires_in: int = Field(alias="expiresIn")
+    token_expires_at: int = Field(alias="tokenExpiresAt")
+
+    model_config = {"populate_by_name": True}
+
+
+class Config(BaseModel):
+    """Platform configuration from /api/config."""
+
+    voice_mode_enabled: bool = Field(default=False, alias="voiceModeEnabled")
+    voice_mode_environment: str = Field(default="prod", alias="voiceModeEnvironment")
+    hidden_task_graphs_mobile: list[str] = Field(default_factory=list, alias="hiddenTaskGraphsMobile")
+
+    model_config = {"populate_by_name": True}

pyindus-0.1.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: pyindus
+Version: 0.1.0
+Summary: Python package for Indus Chat API by Sarvam AI
+Author: Abhishek Verma
+License: MIT
+Keywords: ai,api,chatbot,indus,sarvam
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Description-Content-Type: text/markdown
+
+# PyIndus
+
+A Python package for interacting with [Indus](https://indus.sarvam.ai), a ChatGPT alternative by Sarvam AI.
+
+## Installation
+
+```bash
+pip install pyindus
+```
+
+Or with uv:
+
+```bash
+uv add pyindus
+```
+
+## Quick Start
+
+`IndusClient` acts as a fully-featured, seamless SDK. It **automatically saves, loads, and refreshes sessions** for you.
+
+### 1. Initial Login
+Run this once to authenticate. The client will automatically save your session to `indus_session.json` by default.
+
+```python
+from pyindus import IndusClient
+
+# Login with phone number
+client = IndusClient()
+client.login("+91XXXXXXXXXX")
+
+# Enter the OTP received via SMS
+client.verify_otp("123456")
+
+# The session is now authenticated and saved automatically!
+```
+
+### 2. Immediate Re-use (Like an SDK)
+Run this anywhere else in your project. Because the session was saved, the client automatically loads it on `__init__`. *If the token expires, the client will dynamically refresh it in the background.*
+
+```python
+from pyindus import IndusClient
+
+# Automatically loads the previous session from 'indus_session.json'
+client = IndusClient()
+
+# Chat directly! No need to login again.
+response = client.chat("What is quantum computing?")
+print(response.answer)
+```
+
+## Integration Guide: Custom Paths
+
+If you're building a web app or managing multiple users, you can specify individual session files.
+
+```python
+from pyindus import IndusClient
+
+# Supply a unique path for the user's session
+def handle_user_request(user_id, message):
+    session_path = f"sessions/user_{user_id}.json"
+    
+    # Auto-loads and manages session in this specific file
+    with IndusClient(session_file=session_path) as client:
+        return client.chat(message)
+```
+
+## Advanced Usage
+
+### Working with Specific Models
+Indus supports different "Task Graphs" (models like Sarvam Think, Bulbul, etc.). By default, `IndusClient` selects the first available chat model automatically.
+
+```python
+from pyindus import IndusClient
+
+with IndusClient() as client:
+    # List available models
+    models = client.get_models()
+    for model in models:
+        print(f"{model.name}: {model.description}")
+
+    # Use a specific model
+    response = client.chat("Explain gravity", task_graph_uid=models[-1].uid)
+    print(response.answer)
+```
+
+## License
+
+MIT

pyindus-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyindus/__init__.py,sha256=GmRsrPH2wLM5gM000lydNQhq3Xk-dGJwIthhrmGIvto,694
+pyindus/auth.py,sha256=RkB3N7U0Uyng1agq_VWFERhrORnPTeP8xYW19Dm6lBg,14132
+pyindus/chat.py,sha256=rcCMa1Y-h_QyVE_vQ8ssZtDy3jyVx0pTzLbXCcdLZVQ,6328
+pyindus/cli.py,sha256=cysMBcH0LdqmxyyEJWD2cvVdE4lpxssmdBmqltSnumU,2651
+pyindus/client.py,sha256=I3dKCnNaBJXlUQ_7_OQ0BZFiXqKxCdrAP0jmdiYLwzQ,10012
+pyindus/exceptions.py,sha256=EWxkUA6hvpHX6fu6yySIsMFcPtWgpdHR16Ld_NpWmQk,655
+pyindus/models.py,sha256=7teFzsxoblF9BzKFJD8lOmGXpp1DsKgCGEjmnFYU8hs,5272
+pyindus-0.1.0.dist-info/METADATA,sha256=uYFr9jjv83-B0m5CXUTzGnAww-lBw1EHilvuYaMKbxo,2993
+pyindus-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pyindus-0.1.0.dist-info/entry_points.txt,sha256=lqWkiMrp6xX8TqBBlKtYVFNoPeQMPYh8Pz_as0D0Gos,45
+pyindus-0.1.0.dist-info/RECORD,,

pyindus-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyindus-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyindus = pyindus.cli:main