WebSocket Protocol

import asyncio
import json
import aiohttp

API_KEY = "ok_live_..."
BASE_URL = "https://api.jaot.io"
WS_BASE = "wss://api.jaot.io"

async def solve_with_realtime_progress(problem: dict):
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    }

    async with aiohttp.ClientSession() as session:
        # 1. Start async solve
        async with session.post(
            f"{BASE_URL}/api/v2/solve/async",
            headers=headers,
            json=problem,
        ) as resp:
            data = await resp.json()
            task_id = data["task_id"]
            print(f"Solve started: {task_id}")

        # 2. Connect WebSocket for real-time updates
        ws_url = f"{WS_BASE}/api/v2/ws/executions/{task_id}"
        async with session.ws_connect(ws_url) as ws:
            async for msg in ws:
                if msg.type == aiohttp.WSMsgType.TEXT:
                    data = json.loads(msg.data)
                    msg_type = data.get("type")

                    if msg_type == "status":
                        print(f"Initial status: {data['status']}")

                    elif msg_type == "progress":
                        pct = data.get("progress", 0) * 100
                        obj = data.get("objective_value", "?")
                        gap = data.get("gap", "?")
                        print(f"Progress: {pct:.0f}% | Objective: {obj} | Gap: {gap}")

                    elif msg_type == "completed":
                        result = data["result"]
                        print(f"\nSolve completed!")
                        print(f"Status: {result['status']}")
                        print(f"Objective: {result['objective_value']}")
                        print(f"Solution: {result['solution']}")
                        print(f"Time: {result['solve_time_seconds']}s")
                        print(f"Credits used: {result['credits_used']}")
                        break

                    elif msg_type == "failed":
                        print(f"Solve failed: {data['error']}")
                        break

                elif msg.type == aiohttp.WSMsgType.ERROR:
                    print(f"WebSocket error: {ws.exception()}")
                    break

# Example usage
problem = {
    "name": "production_planning",
    "objective": {
        "sense": "maximize",
        "expression": "50*widgets + 40*gadgets",
    },
    "variables": [
        {"name": "widgets", "type": "integer", "lower_bound": 0, "upper_bound": 100},
        {"name": "gadgets", "type": "integer", "lower_bound": 0, "upper_bound": 80},
    ],
    "constraints": [
        {"name": "machine_hours", "expression": "2*widgets + 3*gadgets <= 240"},
        {"name": "labor_hours", "expression": "4*widgets + 2*gadgets <= 200"},
    ],
}

asyncio.run(solve_with_realtime_progress(problem))

import asyncio
import aiohttp
import json

async def resilient_monitor(task_id: str, max_retries: int = 3):
    ws_url = f"wss://api.jaot.io/api/v2/ws/executions/{task_id}"
    retries = 0

    while retries < max_retries:
        try:
            async with aiohttp.ClientSession() as session:
                async with session.ws_connect(ws_url) as ws:
                    retries = 0  # Reset on successful connect
                    async for msg in ws:
                        if msg.type == aiohttp.WSMsgType.TEXT:
                            data = json.loads(msg.data)
                            if data["type"] in ("completed", "failed", "cancelled"):
                                return data  # Terminal state -- done
                            print(f"Progress: {data.get('progress', 0):.0%}")
        except (aiohttp.ClientError, ConnectionError) as e:
            retries += 1
            wait = min(2 ** retries, 30)  # Exponential backoff, max 30s
            print(f"Connection lost ({e}). Reconnecting in {wait}s...")
            await asyncio.sleep(wait)

    # Fallback to HTTP polling
    print("WebSocket reconnection failed. Falling back to HTTP polling.")
    return await poll_for_result(task_id)

import time
import requests

def poll_for_result(task_id: str, api_key: str, interval: float = 3.0):
    """Poll for solve result via HTTP (WebSocket fallback)."""
    url = f"https://api.jaot.io/api/v2/solve/async/{task_id}"
    headers = {"Authorization": f"Bearer {api_key}"}

    while True:
        response = requests.get(url, headers=headers)
        data = response.json()
        status = data["status"]

        if status == "completed":
            return data["result"]
        elif status == "failed":
            raise Exception(f"Solve failed: {data.get('error')}")
        elif status == "running":
            progress = data.get("progress", 0)
            print(f"Running... {progress:.0%}")

        time.sleep(interval)