""" One simulated customer = one identity + one authenticated HTTP session + one real journey through the IfixKart API. The agent does not insert rows directly. It registers a session through the normal login endpoint, browses the public catalog, adds real cart items, checks out, pays through the simulation-only gateway and verifies the resulting order. """ from __future__ import annotations import asyncio import random import time from dataclasses import asdict, dataclass, field from typing import Any, Optional import httpx from swarm.agents.personas import Persona class JourneyError(RuntimeError): pass @dataclass class JourneyResult: agent_index: int email: str persona_id: str outcome: str order_id: Optional[str] = None order_no: Optional[str] = None amount: float = 0.0 steps: list[str] = field(default_factory=list) error: str = "" duration_ms: int = 0 status_code: int = 0 def to_dict(self) -> dict[str, Any]: return asdict(self) class CustomerAgent: def __init__( self, *, client: httpx.AsyncClient, agent_index: int, account: dict[str, Any], persona: Persona, rng: random.Random, think_time_scale: float = 0.05, request_timeout: float = 45.0, metrics=None, ) -> None: self.client = client self.index = agent_index self.account = account self.persona = persona self.rng = rng self.think_scale = think_time_scale self.request_timeout = request_timeout self.metrics = metrics self.token: Optional[str] = None self.steps: list[str] = [] self.products: list[dict[str, Any]] = [] # ---------- low-level helpers ---------- async def _think(self, low: float, high: float) -> None: delay = self.rng.uniform(low, high) * self.think_scale if delay > 0: await asyncio.sleep(delay) async def _request( self, method: str, path: str, *, expected: tuple[int, ...] = (200,), **kwargs, ) -> httpx.Response: headers = kwargs.pop("headers", {}) headers.setdefault("user-agent", f"IfixKartSwarm/{self.persona.device}") if self.token: headers.setdefault("authorization", f"Bearer {self.token}") started = time.perf_counter() try: response = await self.client.request( method, path, headers=headers, timeout=self.request_timeout, **kwargs, ) except Exception as exc: if self.metrics: await self.metrics.record_request(path, 0, time.perf_counter() - started, error=type(exc).__name__) raise JourneyError(f"{method} {path} failed: {type(exc).__name__}: {exc}") from exc elapsed = time.perf_counter() - started if self.metrics: await self.metrics.record_request(path, response.status_code, elapsed) if response.status_code not in expected: text = response.text[:500].replace("\n", " ") raise JourneyError(f"{method} {path} -> {response.status_code}: {text}") return response # ---------- journey steps ---------- async def _login(self) -> None: response = await self._request( "POST", "/api/v1/customer/auth/login", expected=(200,), json={"email": self.account["email"], "password": self.account["password"]}, ) self.token = response.json()["access_token"] self.steps.append("login") async def _get_address(self) -> str: response = await self._request("GET", "/api/v1/customer/profile/addresses", expected=(200,)) addresses = response.json() if addresses: self.steps.append("load_address") return addresses[0]["address_id"] payload = { "address_type": "SHIPPING", "full_name": f"{self.account['first_name']} {self.account['last_name']}", "phone": f"9{self.rng.randint(100000000, 999999999)}"[:10], "street_address": f"{self.rng.randint(1, 200)}, {self.rng.choice(['MG Road', 'Anna Nagar', 'Banjara Hills', 'Park Street'])}", "city": self.persona.city, "state": self.persona.state, "pincode": self.persona.pincode, "is_default": True, } response = await self._request("POST", "/api/v1/customer/profile/addresses", expected=(200,), json=payload) self.steps.append("create_address") return response.json()["address_id"] async def _catalog(self) -> None: page = 1 products: list[dict[str, Any]] = [] while True: response = await self._request( "GET", "/api/v1/catalog/products", expected=(200,), params={"page": page, "limit": 100}, ) body = response.json() batch = body.get("products") or [] products.extend(batch) if not batch or len(products) >= int(body.get("total") or 0) or page >= 3: break page += 1 self.products = [p for p in products if p.get("first_variant_id")] if not self.products: raise JourneyError("catalog returned no purchasable variants") self.steps.append(f"catalog:{len(self.products)}") def _choose_products(self) -> list[dict[str, Any]]: def score(product: dict[str, Any]) -> tuple[float, float]: name = (product.get("name") or "").lower() price = float(product.get("price") or 0) affinity = 0.0 for keyword in self.persona.preferred_keywords: if keyword in name: affinity += 2.0 if price <= self.persona.budget_max: affinity += 1.0 else: affinity -= 2.0 return (affinity, self.rng.random()) ranked = sorted(self.products, key=score, reverse=True) in_budget = [p for p in ranked if float(p.get("price") or 0) <= self.persona.budget_max] chosen = in_budget or sorted(self.products, key=lambda p: float(p.get("price") or 0)) return chosen[: max(4, self.persona.browse_depth + 2)] async def _browse(self) -> bool: candidates = self._choose_products() depth = min(self.persona.browse_depth, len(candidates)) for product in candidates[:depth]: slug = product.get("slug") if not slug: continue try: await self._request("GET", f"/api/v1/catalog/products/detail/{slug}", expected=(200,)) except JourneyError: # A detail page 404 should not kill the whole journey. pass await self._think(1.0, 4.0) self.steps.append(f"browse:{depth}") return self.rng.random() < self.persona.conversion_prob async def _add_to_cart(self, candidates: list[dict[str, Any]]) -> float: added = 0 total_qty = 0 desired = 1 if self.rng.random() < 0.25: desired = 2 for product in candidates: if added >= 2: break qty = self.persona.quantity_pref if added == 0 else 1 if desired == 1: qty = 1 try: response = await self._request( "POST", "/api/v1/cart/items", expected=(200,), json={"variant_id": product["first_variant_id"], "qty": qty}, ) added += 1 total_qty += qty self.steps.append(f"cart_add:{product.get('slug', '')[:40]}:{qty}") await self._think(1.0, 3.0) if response.json().get("total_amount") is not None: continue except JourneyError: continue if added == 0: raise JourneyError("could not add any item to cart") self.steps.append(f"cart_items:{total_qty}") return total_qty async def run(self) -> JourneyResult: started = time.perf_counter() result = JourneyResult( agent_index=self.index, email=self.account["email"], persona_id=self.persona.persona_id, outcome="ERROR", ) try: await self._login() await self._think(0.5, 2.0) address_id = await self._get_address() await self._think(0.5, 2.0) await self._catalog() await self._think(1.0, 3.0) candidates = self._choose_products() wants_to_buy = await self._browse() if not wants_to_buy: result.outcome = "BROWSE_ABANDON" result.steps = self.steps result.duration_ms = int((time.perf_counter() - started) * 1000) return result await self._add_to_cart(candidates) await self._think(1.0, 4.0) if self.rng.random() < self.persona.cart_abandon_prob: result.outcome = "CART_ABANDON" result.steps = self.steps result.duration_ms = int((time.perf_counter() - started) * 1000) return result checkout = await self._request( "POST", "/api/v1/checkout/create", expected=(200,), json={"address_id": address_id, "payment_method": "RAZORPAY"}, ) order = checkout.json() result.order_id = order.get("order_id") result.order_no = order.get("order_no") result.amount = float(order.get("final_amount") or 0) self.steps.append("checkout") await self._think(1.0, 4.0) if self.rng.random() < self.persona.payment_fail_prob: try: await self._request( "POST", "/api/v1/payment/cancel", expected=(200,), json={"order_id": result.order_id, "reason": "Simulated payment failure/abandonment"}, ) except JourneyError: pass result.outcome = "PAYMENT_FAILED" result.steps = self.steps result.duration_ms = int((time.perf_counter() - started) * 1000) return result paid = await self._request( "POST", "/api/v1/payment/simulate", expected=(200,), json={"order_id": result.order_id, "note": "IfixKart swarm simulated payment"}, ) self.steps.append("payment_simulated") body = paid.json() if body.get("status") != "SUCCESS": raise JourneyError(f"simulated payment did not succeed: {body}") verified = await self._request( "GET", f"/api/v1/orders/{result.order_id}", expected=(200,), ) final = verified.json() result.outcome = "ORDER_CONFIRMED" result.amount = float(final.get("final_amount") or result.amount) self.steps.append("order_verified") return result except JourneyError as exc: result.outcome = "ERROR" result.error = str(exc) result.status_code = 0 except Exception as exc: # defensive: never let one agent kill the fleet result.outcome = "ERROR" result.error = f"{type(exc).__name__}: {exc}" finally: result.steps = self.steps result.duration_ms = int((time.perf_counter() - started) * 1000) return result