change to (remoteJid)

app/api/routes.py

@@ -136,7 +136,7 @@ async def llm_tool_call_debug(
     tool_calls: list[dict[str, Any]] = []
     tool_results: list[dict[str, Any]] = []
     registry = container.conversation._tool_registry(
-        {"id": "admin-debug", "phone_number": "", "name": "admin-debug"},
+        {"id": "admin-debug", "remoteJid": "", "name": "admin-debug"},
         sender_phone="admin-debug",
         user_mode="passenger",
     )
@@ -187,7 +187,7 @@ async def driver_service_debug(
     tool_results: list[dict[str, Any]] = []
     customer = {
         "id": "debug",
-        "phone_number": request.client_number,
+        "remoteJid": request.client_number,
         "name": "driver-debug",
     }
     registry = container.conversation._tool_registry(

app/database/supabase.py

@@ -35,19 +35,19 @@ class SupabaseRepository:
     async def upsert_customer(
         self,
         *,
-        phone_number: str,
+        remote_jid: str,
         name: str | None = None,
         preferred_language: str | None = None,
     ) -> dict[str, Any]:
         payload = {
-            "phone_number": phone_number,
+            "remoteJid": remote_jid,
             "name": name,
             "preferred_language": preferred_language,
         }
         payload = {key: value for key, value in payload.items() if value is not None}
         response = await (
             self.client.table("customers")
-            .upsert(payload, on_conflict="phone_number")
+            .upsert(payload, on_conflict="remoteJid")
             .execute()
         )
         data = _response_data(response)
@@ -149,7 +149,7 @@ class SupabaseRepository:
     async def list_active_trips(self) -> list[dict[str, Any]]:
         query = (
             self.client.table("driver_trips")
-            .select("*, drivers(*), driver_cars(*)")
+            .select("*, drivers(*, customers(*)), driver_cars(*)")
             .eq("status", "active")
             .gt("available_seats", 0)
         )
@@ -166,7 +166,7 @@ class SupabaseRepository:
             return []
         response = await (
             self.client.table("driver_trips")
-            .select("*, drivers(*), driver_cars(*)")
+            .select("*, drivers(*, customers(*)), driver_cars(*)")
             .in_("id", trip_ids)
             .execute()
         )
@@ -183,7 +183,7 @@ class SupabaseRepository:
     ) -> list[dict[str, Any]]:
         query = (
             self.client.table("driver_trips")
-            .select("*, drivers(*), driver_cars(*)")
+            .select("*, drivers(*, customers(*)), driver_cars(*)")
             .eq("status", "active")
             .gt("available_seats", 0)
         )
@@ -308,27 +308,27 @@ class SupabaseRepository:
     async def get_trip_by_id(self, trip_id: str) -> dict[str, Any] | None:
         response = await (
             self.client.table("driver_trips")
-            .select("*, drivers(*), driver_cars(*)")
+            .select("*, drivers(*, customers(*)), driver_cars(*)")
             .eq("id", trip_id)
             .maybe_single()
             .execute()
         )
         return _response_data(response)
 
-    async def get_driver_by_phone(self, phone_number: str) -> dict[str, Any] | None:
+    async def get_driver_by_remoteJid(self, remote_jid: str) -> dict[str, Any] | None:
         response = await (
             self.client.table("drivers")
-            .select("*")
-            .eq("phone_number", phone_number)
+            .select("*, customers!inner(*)")
+            .eq("customers.remoteJid", remote_jid)
             .maybe_single()
             .execute()
         )
         return _response_data(response)
 
-    async def create_driver(self, *, name: str, phone_number: str) -> dict[str, Any]:
+    async def create_driver(self, *, customer_id: str) -> dict[str, Any]:
         response = await (
             self.client.table("drivers")
-            .insert({"name": name, "phone_number": phone_number, "status": "active"})
+            .insert({"customer_id": customer_id, "status": "active"})
             .execute()
         )
         data = _response_data(response)
@@ -338,7 +338,14 @@ class SupabaseRepository:
             .insert({"driver_id": driver["id"], "balance": 0})
             .execute()
         )
-        return driver
+        driver_response = await (
+            self.client.table("drivers")
+            .select("*, customers(*)")
+            .eq("id", str(driver["id"]))
+            .maybe_single()
+            .execute()
+        )
+        return _response_data(driver_response)
 
     async def get_driver_latest_trip(self, driver_id: str) -> dict[str, Any] | None:
         response = await (

app/models/domain.py

@@ -8,7 +8,7 @@ UserMode = Literal["new_user", "driver", "passenger"]
 @dataclass(slots=True)
 class WhatsAppInboundMessage:
     message_id: str
-    from_phone: str
+    remoteJid: str
     text: str
     timestamp: str | None = None
     profile_name: str | None = None

app/services/conversation_service.py

@@ -70,7 +70,7 @@ class ConversationService:
             return None
 
         customer = await self.repository.upsert_customer(
-            phone_number=inbound.from_phone,
+            remote_jid=inbound.remoteJid,
             name=inbound.profile_name,
         )
         current_message = await self.repository.create_message(
@@ -88,7 +88,7 @@ class ConversationService:
         )
 
         user_mode = _resolve_user_mode(customer)
-        registry = self._tool_registry(customer, sender_phone=inbound.from_phone, user_mode=user_mode)
+        registry = self._tool_registry(customer, remoteJid=inbound.remoteJid, user_mode=user_mode)
         reply = await self.ai.generate_reply(
             messages=self._ai_messages(context, user_mode=user_mode),
             tools=get_tool_schemas(user_mode),
@@ -101,14 +101,14 @@ class ConversationService:
             message=reply,
             metadata={"provider_flow": "groq_primary_hf_fallback", "user_mode": user_mode},
         )
-        # await self.whatsapp.send_text(inbound.from_phone, reply)
+        await self.whatsapp.send_text(inbound.remoteJid, reply)
         return reply
 
     def _tool_registry(
         self,
         customer: dict[str, Any],
         *,
-        sender_phone: str,
+        remoteJid: str,
         user_mode: UserMode,
     ) -> ToolRegistry:
         handlers = FalsaToolHandlers(
@@ -116,7 +116,7 @@ class ConversationService:
             embeddings=self.embeddings,
             whatsapp=self.whatsapp,
             customer=customer,
-            sender_phone=sender_phone,
+            remoteJid=remoteJid,
             embedding_model=self.settings.jina_embedding_model,
         )
         registry = ToolRegistry()

app/tools/handlers.py

@@ -25,14 +25,14 @@ class FalsaToolHandlers:
         embeddings: JinaEmbeddingService,
         whatsapp: WhatsAppClient,
         customer: dict[str, Any],
-        sender_phone: str,
+        remoteJid: str,
         embedding_model: str,
     ) -> None:
         self.repository = repository
         self.embeddings = embeddings
         self.whatsapp = whatsapp
         self.customer = customer
-        self.sender_phone = sender_phone
+        self.remoteJid = remoteJid
         self.embedding_model = embedding_model
 
     async def about_falsa(self, arguments: dict[str, Any]) -> ToolResult:
@@ -188,11 +188,13 @@ class FalsaToolHandlers:
         notification_status = "sent"
         notification_error = None
         try:
-            driver_phone = (_first_or_dict(trip.get("drivers")) or {}).get("phone_number")
-            if not driver_phone:
-                raise WhatsAppClientError("Driver phone number is missing")
+            driver_record = _first_or_dict(trip.get("drivers")) or {}
+            driver_customer = driver_record.get("customers") or {}
+            driver_remote_jid = driver_customer.get("remoteJid") or driver_record.get("remoteJid")
+            if not driver_remote_jid:
+                raise WhatsAppClientError("Driver remoteJid is missing")
             await self.whatsapp.send_text(
-                driver_phone,
+                driver_remote_jid,
                 _driver_notification_text(
                     customer=self.customer,
                     trip=trip,
@@ -226,8 +228,8 @@ class FalsaToolHandlers:
         if not name:
             return ToolResult(ok=False, data={}, error="name is required")
 
-        phone = self.sender_phone
-        existing = await self.repository.get_driver_by_phone(phone)
+        remote_jid = self.remoteJid
+        existing = await self.repository.get_driver_by_remoteJid(remote_jid)
         if existing:
             return ToolResult(
                 ok=False,
@@ -235,19 +237,19 @@ class FalsaToolHandlers:
                 error="Driver account already exists for this WhatsApp number",
             )
 
-        driver = await self.repository.create_driver(name=name, phone_number=phone)
+        driver = await self.repository.create_driver(customer_id=str(self.customer["id"]))
         return ToolResult(
             ok=True,
             data={
                 "driver_id": driver["id"],
-                "name": driver.get("name"),
-                "phone_number": driver.get("phone_number"),
+                "name": self.customer.get("name"),
+                "remoteJid": self.customer.get("remoteJid"),
                 "message": "Driver account created successfully.",
             },
         )
 
     async def check_driver_info(self, arguments: dict[str, Any]) -> ToolResult:
-        driver = await self.repository.get_driver_by_phone(self.sender_phone)
+        driver = await self.repository.get_driver_by_remoteJid(self.remoteJid)
         if not driver:
             return ToolResult(
                 ok=False,
@@ -258,6 +260,7 @@ class FalsaToolHandlers:
                 ),
             )
 
+        customer_info = driver.get("customers", {})
         cars = await self.repository.list_driver_cars(str(driver["id"]))
         upcoming_trips = await self.repository.list_driver_trips(str(driver["id"]))
 
@@ -265,8 +268,8 @@ class FalsaToolHandlers:
             ok=True,
             data={
                 "driver_id": driver["id"],
-                "name": driver.get("name"),
-                "phone_number": driver.get("phone_number"),
+                "name": customer_info.get("name") or driver.get("name"),
+                "remoteJid": customer_info.get("remoteJid") or driver.get("remoteJid"),
                 "status": driver.get("status"),
                 "vehicle_count": len(cars),
                 "active_trip_count": len(upcoming_trips),
@@ -286,7 +289,7 @@ class FalsaToolHandlers:
         )
 
     async def check_driver_trips(self, arguments: dict[str, Any]) -> ToolResult:
-        driver = await self.repository.get_driver_by_phone(self.sender_phone)
+        driver = await self.repository.get_driver_by_remoteJid(self.remoteJid)
         if not driver:
             return ToolResult(
                 ok=False,
@@ -313,7 +316,7 @@ class FalsaToolHandlers:
         )
 
     async def add_driver_car(self, arguments: dict[str, Any]) -> ToolResult:
-        driver = await self.repository.get_driver_by_phone(self.sender_phone)
+        driver = await self.repository.get_driver_by_remoteJid(self.remoteJid)
         if not driver:
             return ToolResult(
                 ok=False,
@@ -352,7 +355,7 @@ class FalsaToolHandlers:
         )
 
     async def add_trip_by_driver(self, arguments: dict[str, Any]) -> ToolResult:
-        driver = await self.repository.get_driver_by_phone(self.sender_phone)
+        driver = await self.repository.get_driver_by_remoteJid(self.remoteJid)
         if not driver:
             return ToolResult(
                 ok=False,
@@ -503,7 +506,7 @@ class FalsaToolHandlers:
         )
 
     async def switch_to_driver(self, arguments: dict[str, Any]) -> ToolResult:
-        driver = await self.repository.get_driver_by_phone(self.sender_phone)
+        driver = await self.repository.get_driver_by_remoteJid(self.remoteJid)
         if not driver:
             return ToolResult(
                 ok=False,
@@ -732,8 +735,8 @@ def _driver_notification_text(
 ) -> str:
     return (
         "New FALSA booking lead\n"
-        f"Customer: {customer.get('name') or customer.get('phone_number')}\n"
-        f"Phone: {customer.get('phone_number')}\n"
+        f"Customer: {customer.get('name') or customer.get('remoteJid')}\n"
+        f"Remote JID: {customer.get('remoteJid')}\n"
         f"Trip: {trip.get('departure')} -> {trip.get('destination')}\n"
         f"Departure: {trip_departure_date(trip)} {trip_departure_bucket(trip)}\n"
         f"Seats requested: {requested_seats}\n"

app/whatsapp/parser.py

@@ -22,19 +22,19 @@ def parse_inbound_messages(payload: dict[str, Any]) -> list[WhatsAppInboundMessa
                 if message_type not in SUPPORTED_MESSAGE_TYPES:
                     continue
 
-                from_phone = message.get("from")
+                remoteJid = message.get("from")
                 message_id = message.get("id")
                 text = message.get("text", {}).get("body")
-                if not from_phone or not message_id or text is None:
+                if not remoteJid or not message_id or text is None:
                     continue
 
                 messages.append(
                     WhatsAppInboundMessage(
                         message_id=message_id,
-                        from_phone=from_phone,
+                        remoteJid=remoteJid,
                         text=text,
                         timestamp=message.get("timestamp"),
-                        profile_name=contacts_by_wa_id.get(from_phone),
+                        profile_name=contacts_by_wa_id.get(remoteJid),
                         phone_number_id=phone_number_id,
                         raw=message,
                     )

supabase/migrations/202605210001_initial_schema.sql

@@ -13,7 +13,7 @@ $$;
 create table if not exists public.customers (
   id uuid primary key default gen_random_uuid(),
   name text,
-  phone_number text not null unique,
+  "remoteJid" text not null unique,
   preferred_language text check (preferred_language in ('ar', 'en')),
   created_at timestamptz not null default now(),
   updated_at timestamptz not null default now()
@@ -21,8 +21,7 @@ create table if not exists public.customers (
 
 create table if not exists public.drivers (
   id uuid primary key default gen_random_uuid(),
-  name text not null,
-  phone_number text not null unique,
+  customer_id uuid not null unique references public.customers(id) on delete cascade,
   status text not null default 'active' check (status in ('active', 'inactive', 'suspended')),
   rating numeric(3,2),
   created_at timestamptz not null default now(),

supabase/migrations/202606020001_supabase_jina_vectors.sql

@@ -117,8 +117,8 @@ as $$
       driver_trips.total_seats,
       driver_trips.price,
       driver_trips.status,
-      drivers.name as driver_name,
-      drivers.phone_number as driver_phone_number,
+      customers.name as driver_name,
+      customers."remoteJid" as driver_phone_number,
       driver_cars.car_type,
       driver_trip_embeddings.chunk_text,
       1 - (driver_trip_embeddings.embedding <=> query_embedding) as similarity,
@@ -137,6 +137,7 @@ as $$
     from public.driver_trip_embeddings
     join public.driver_trips on driver_trips.id = driver_trip_embeddings.trip_id
     left join public.drivers on drivers.id = driver_trips.driver_id
+    left join public.customers on customers.id = drivers.customer_id
     left join public.driver_cars on driver_cars.id = driver_trips.car_id
     where driver_trips.status = 'active'
       and driver_trips.available_seats >= coalesce(filter_seats, 1)

supabase/migrations/202606170001_driver_customer_identity.sql

@@ -0,0 +1,32 @@
+-- Migration: driver records now reference customers as primary identity
+-- 1) Add customer_id foreign key to drivers
+-- 2) Populate customer_id from existing customer records when possible
+-- 3) Enforce uniqueness and non-nullability
+-- 4) Drop redundant driver identity columns
+
+ALTER TABLE public.drivers
+ADD COLUMN customer_id uuid;
+
+ALTER TABLE public.customers
+RENAME COLUMN phone_number TO "remoteJid";
+
+UPDATE public.drivers
+SET customer_id = public.customers.id
+FROM public.customers
+WHERE public.drivers.phone_number = public.customers."remoteJid";
+
+ALTER TABLE public.drivers
+ADD CONSTRAINT drivers_customer_id_key UNIQUE (customer_id);
+
+ALTER TABLE public.drivers
+ALTER COLUMN customer_id SET NOT NULL;
+
+ALTER TABLE public.drivers
+ADD CONSTRAINT drivers_customer_id_fkey
+    FOREIGN KEY (customer_id)
+    REFERENCES public.customers(id)
+    ON DELETE CASCADE;
+
+ALTER TABLE public.drivers
+DROP COLUMN name,
+DROP COLUMN phone_number;

tests/conftest.py

@@ -98,8 +98,8 @@ def test_app(settings: Settings) -> Any:
 
 class FakeRepository:
     def __init__(self) -> None:
-        self.customers_by_phone: dict[str, dict[str, Any]] = {}
-        self.drivers_by_phone: dict[str, dict[str, Any]] = {}
+        self.customers_by_remote_jid: dict[str, dict[str, Any]] = {}
+        self.drivers_by_remote_jid: dict[str, dict[str, Any]] = {}
         self.driver_cars_by_driver: dict[str, list[dict[str, Any]]] = {}
         self.latest_trips_by_driver: dict[str, dict[str, Any]] = {}
         self.created_drivers: list[dict[str, Any]] = []
@@ -117,20 +117,20 @@ class FakeRepository:
     async def upsert_customer(
         self,
         *,
-        phone_number: str,
+        remote_jid: str,
         name: str | None = None,
         preferred_language: str | None = None,
     ) -> dict[str, Any]:
-        customer = self.customers_by_phone.get(phone_number)
+        customer = self.customers_by_remote_jid.get(remote_jid)
         if customer is None:
             customer = {
-                "id": f"cust-{len(self.customers_by_phone) + 1}",
-                "phone_number": phone_number,
+                "id": f"cust-{len(self.customers_by_remote_jid) + 1}",
+                "remoteJid": remote_jid,
                 "name": name,
                 "preferred_language": preferred_language,
                 "user_mode": None,
             }
-            self.customers_by_phone[phone_number] = customer
+            self.customers_by_remote_jid[remote_jid] = customer
         elif name:
             customer["name"] = name
         return customer
@@ -141,7 +141,7 @@ class FakeRepository:
         customer_id: str,
         user_mode: str,
     ) -> dict[str, Any]:
-        for customer in self.customers_by_phone.values():
+        for customer in self.customers_by_remote_jid.values():
             if customer["id"] == customer_id:
                 customer["user_mode"] = user_mode
                 return customer
@@ -153,7 +153,7 @@ class FakeRepository:
         customer_id: str,
         name: str,
     ) -> dict[str, Any]:
-        for customer in self.customers_by_phone.values():
+        for customer in self.customers_by_remote_jid.values():
             if customer["id"] == customer_id:
                 customer["name"] = name
                 return customer
@@ -253,17 +253,23 @@ class FakeRepository:
         self.notification_updates.append(update)
         return update
 
-    async def get_driver_by_phone(self, phone_number: str) -> dict[str, Any] | None:
-        return self.drivers_by_phone.get(phone_number)
+    async def get_driver_by_phone(self, remote_jid: str) -> dict[str, Any] | None:
+        return self.drivers_by_remote_jid.get(remote_jid)
 
-    async def create_driver(self, *, name: str, phone_number: str) -> dict[str, Any]:
+    async def create_driver(self, *, customer_id: str) -> dict[str, Any]:
+        customer = next(
+            (customer for customer in self.customers_by_remote_jid.values() if customer["id"] == customer_id),
+            None,
+        )
+        if customer is None:
+            raise KeyError(customer_id)
         driver = {
-            "id": f"driver-{len(self.drivers_by_phone) + 1}",
-            "name": name,
-            "phone_number": phone_number,
+            "id": f"driver-{len(self.drivers_by_remote_jid) + 1}",
+            "customer_id": customer_id,
             "status": "active",
+            "customers": customer,
         }
-        self.drivers_by_phone[phone_number] = driver
+        self.drivers_by_remote_jid[customer["remoteJid"]] = driver
         self.created_drivers.append(driver)
         return driver
 
@@ -312,7 +318,7 @@ class FakeRepository:
         car_id = kwargs.get("car_id")
         cars = self.driver_cars_by_driver.get(driver_id, [])
         driver = next(
-            (row for row in self.drivers_by_phone.values() if row["id"] == driver_id),
+            (row for row in self.drivers_by_remote_jid.values() if row["id"] == driver_id),
             {"name": "Driver"},
         )
         matched_car = next(

tests/test_conversation_service.py

@@ -8,7 +8,7 @@ from tests.conftest import FakeAI, FakeEmbeddings, FakeRepository, FakeWhatsApp
 @pytest.mark.asyncio
 async def test_conversation_stores_messages_uses_last_four_context_and_sends_reply(settings):
     repository = FakeRepository()
-    customer = await repository.upsert_customer(phone_number="967700000001", name="Customer")
+    customer = await repository.upsert_customer(remote_jid="967700000001", name="Customer")
     for index in range(6):
         await repository.create_message(
             customer_id=customer["id"],
@@ -60,7 +60,7 @@ async def test_conversation_stores_messages_uses_last_four_context_and_sends_rep
 @pytest.mark.asyncio
 async def test_conversation_skips_duplicate_whatsapp_message(settings):
     repository = FakeRepository()
-    customer = await repository.upsert_customer(phone_number="967700000001")
+    customer = await repository.upsert_customer(remote_jid="967700000001")
     await repository.create_message(
         customer_id=customer["id"],
         sender_type="customer",
@@ -93,7 +93,7 @@ async def test_conversation_skips_duplicate_whatsapp_message(settings):
 @pytest.mark.asyncio
 async def test_conversation_uses_passenger_tools_when_user_mode_is_passenger(settings):
     repository = FakeRepository()
-    customer = await repository.upsert_customer(phone_number="967700000001", name="Customer")
+    customer = await repository.upsert_customer(remote_jid="967700000001", name="Customer")
     customer["user_mode"] = "passenger"
     ai = FakeAI(reply="Passenger reply")
     service = ConversationService(

tests/test_tools.py

@@ -16,7 +16,7 @@ def make_handlers(
         repository=repository or FakeRepository(),
         embeddings=embeddings or FakeEmbeddings(),
         whatsapp=whatsapp or FakeWhatsApp(),
-        customer=customer or {"id": "cust-1", "phone_number": sender_phone},
+        customer=customer or {"id": "cust-1", "remoteJid": sender_phone},
         sender_phone=sender_phone,
         embedding_model="jina-embeddings-v5-text-small",
     )
@@ -43,7 +43,7 @@ def trip(
         "total_seats": 4,
         "price": "50.00",
         "status": status,
-        "drivers": {"name": "Ali", "phone_number": "967700000009"},
+        "drivers": {"name": "Ali", "remoteJid": "967700000009"},
         "driver_cars": {"car_type": car_type},
     }
 
@@ -162,7 +162,7 @@ async def test_create_booking_lead_notifies_driver():
     handlers = make_handlers(
         repository=repository,
         whatsapp=whatsapp,
-        customer={"id": "cust-1", "phone_number": "967700000001", "name": "Mona"},
+        customer={"id": "cust-1", "remoteJid": "967700000001", "name": "Mona"},
     )
 
     result = await handlers.create_booking_lead(
@@ -210,22 +210,20 @@ async def test_create_driver_account_uses_sender_phone():
     repository = FakeRepository()
     handlers = make_handlers(repository=repository, sender_phone="967700000010")
 
-    result = await handlers.create_driver_account(
-        {"name": "Ali Driver", "phone_number": "967700000099"}
-    )
+    result = await handlers.create_driver_account({"name": "Ali Driver"})
 
     assert result.ok is True
-    assert repository.created_drivers[0]["phone_number"] == "967700000010"
-    assert repository.drivers_by_phone["967700000010"]["name"] == "Ali Driver"
+    assert repository.created_drivers[0]["customers"]["remoteJid"] == "967700000010"
+    assert repository.drivers_by_remote_jid["967700000010"]["name"] == "Ali Driver"
 
 
 @pytest.mark.asyncio
 async def test_create_driver_account_rejects_duplicate():
     repository = FakeRepository()
-    repository.drivers_by_phone["967700000010"] = {
+    repository.drivers_by_remote_jid["967700000010"] = {
         "id": "driver-1",
         "name": "Ali",
-        "phone_number": "967700000010",
+        "remoteJid": "967700000010",
     }
     handlers = make_handlers(repository=repository, sender_phone="967700000010")
 
@@ -257,10 +255,10 @@ async def test_add_trip_by_driver_requires_account():
 @pytest.mark.asyncio
 async def test_add_driver_car_accepts_name_only():
     repository = FakeRepository()
-    repository.drivers_by_phone["967700000010"] = {
+    repository.drivers_by_remote_jid["967700000010"] = {
         "id": "driver-1",
         "name": "Ali",
-        "phone_number": "967700000010",
+        "remoteJid": "967700000010",
     }
     handlers = make_handlers(repository=repository, sender_phone="967700000010")
 
@@ -276,10 +274,10 @@ async def test_add_driver_car_accepts_name_only():
 @pytest.mark.asyncio
 async def test_check_driver_info_returns_account_summary():
     repository = FakeRepository()
-    repository.drivers_by_phone["967700000010"] = {
+    repository.drivers_by_remote_jid["967700000010"] = {
         "id": "driver-1",
         "name": "Ali",
-        "phone_number": "967700000010",
+        "remoteJid": "967700000010",
         "status": "active",
     }
     repository.driver_cars_by_driver["driver-1"] = [
@@ -314,10 +312,10 @@ async def test_check_driver_info_returns_account_summary():
 @pytest.mark.asyncio
 async def test_check_driver_trips_returns_upcoming_trips():
     repository = FakeRepository()
-    repository.drivers_by_phone["967700000010"] = {
+    repository.drivers_by_remote_jid["967700000010"] = {
         "id": "driver-1",
         "name": "Ali",
-        "phone_number": "967700000010",
+        "remoteJid": "967700000010",
     }
     repository.trips_by_id["trip-1"] = {
         "id": "trip-1",
@@ -367,10 +365,10 @@ async def test_check_driver_info_requests_driver_registration_if_unregistered():
 @pytest.mark.asyncio
 async def test_add_trip_by_driver_uses_latest_trip_defaults():
     repository = FakeRepository()
-    repository.drivers_by_phone["967700000010"] = {
+    repository.drivers_by_remote_jid["967700000010"] = {
         "id": "driver-1",
         "name": "Ali",
-        "phone_number": "967700000010",
+        "remoteJid": "967700000010",
     }
     repository.driver_cars_by_driver["driver-1"] = [
         {"id": "car-1", "car_type": "SUV", "seat_count": 4},
@@ -409,10 +407,10 @@ async def test_add_trip_by_driver_uses_latest_trip_defaults():
 @pytest.mark.asyncio
 async def test_add_trip_by_driver_resolves_vehicle_type_by_name():
     repository = FakeRepository()
-    repository.drivers_by_phone["967700000010"] = {
+    repository.drivers_by_remote_jid["967700000010"] = {
         "id": "driver-1",
         "name": "Ali",
-        "phone_number": "967700000010",
+        "remoteJid": "967700000010",
     }
     repository.driver_cars_by_driver["driver-1"] = [
         {"id": "car-1", "car_type": "باص", "plate_number": "1234", "seat_count": 14},
@@ -440,10 +438,10 @@ async def test_add_trip_by_driver_resolves_vehicle_type_by_name():
 @pytest.mark.asyncio
 async def test_add_trip_by_driver_indexes_new_trip():
     repository = FakeRepository()
-    repository.drivers_by_phone["967700000010"] = {
+    repository.drivers_by_remote_jid["967700000010"] = {
         "id": "driver-1",
         "name": "Ali",
-        "phone_number": "967700000010",
+        "remoteJid": "967700000010",
     }
     repository.driver_cars_by_driver["driver-1"] = [
         {"id": "car-1", "car_type": "SUV", "seat_count": 4},
@@ -471,7 +469,7 @@ async def test_add_trip_by_driver_indexes_new_trip():
 @pytest.mark.asyncio
 async def test_switch_to_driver_requires_existing_driver_account():
     repository = FakeRepository()
-    customer = {"id": "cust-1", "phone_number": "967700000001"}
+    customer = {"id": "cust-1", "remoteJid": "967700000001"}
     handlers = make_handlers(repository=repository, customer=customer)
 
     result = await handlers.switch_to_driver({})
@@ -483,11 +481,11 @@ async def test_switch_to_driver_requires_existing_driver_account():
 @pytest.mark.asyncio
 async def test_switch_to_driver_updates_customer_mode():
     repository = FakeRepository()
-    customer = await repository.upsert_customer(phone_number="967700000001")
-    repository.drivers_by_phone["967700000001"] = {
+    customer = await repository.upsert_customer(remote_jid="967700000001")
+    repository.drivers_by_remote_jid["967700000001"] = {
         "id": "driver-1",
         "name": "Ali",
-        "phone_number": "967700000001",
+        "remoteJid": "967700000001",
     }
     handlers = make_handlers(repository=repository, customer=customer)
 
@@ -501,7 +499,7 @@ async def test_switch_to_driver_updates_customer_mode():
 @pytest.mark.asyncio
 async def test_switch_to_passenger_updates_mode_and_optional_name():
     repository = FakeRepository()
-    customer = await repository.upsert_customer(phone_number="967700000001")
+    customer = await repository.upsert_customer(remote_jid="967700000001")
     handlers = make_handlers(repository=repository, customer=customer)
 
     result = await handlers.switch_to_passenger({"name": "Sara"})
@@ -515,7 +513,7 @@ async def test_switch_to_passenger_updates_mode_and_optional_name():
 @pytest.mark.asyncio
 async def test_switch_to_passenger_without_name():
     repository = FakeRepository()
-    customer = await repository.upsert_customer(phone_number="967700000001", name="Existing")
+    customer = await repository.upsert_customer(remote_jid="967700000001", name="Existing")
     handlers = make_handlers(repository=repository, customer=customer)
 
     result = await handlers.switch_to_passenger({})