walla-cli 0.1.6__tar.gz → 0.1.7__tar.gz

{walla_cli-0.1.6 → walla_cli-0.1.7}/AGENTS.md

@@ -60,4 +60,6 @@ Ranks: models 10 → exceptions 15 → http 20 → core 30 → search/account/hu
 - **Do** require `--yes` for say/offer.
 - **Don't** commit session.json, cookies, or tokens.
 - **Don't** invent wire shapes without a fixture.
+- **Don't** post buyer offers as `{item_id, amount, currency}` (HTTP 400).
+  Use `walla.account.offer_wire.build_offer_body` / `fixtures/offer_buyer_request.json`.
 - **Don't** require `.env` credentials; login is cookie paste.

{walla_cli-0.1.6 → walla_cli-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: walla-cli
-Version: 0.1.6
+Version: 0.1.7
 Summary: Wallapop.es CLI - look · offer · talk for humans and agents
 Project-URL: Homepage, https://github.com/berendgort/wallapop-cli
 Project-URL: Repository, https://github.com/berendgort/wallapop-cli

{walla_cli-0.1.6 → walla_cli-0.1.7}/docs/WIRE.md

@@ -44,13 +44,17 @@ login ever succeeds.
 
 ## Messaging / offers (auth)
 
-Reported shapes (confirm with a live token before trusting writes):
-
-- Inbox: `GET /api/v3/conversations`
-- Messages: `GET|POST /api/v3/conversations/{id}/messages`
+- Open chat (listing **Chat** button): `POST /api/v3/conversations`
+  body `{ "item_id": "<hash>" }` → `{ conversation_id, item_id, other_user_id, channel }`.
+- Inbox: `GET /bff/messaging/inbox?page_size=&max_messages=` (not `/api/v3/conversations`, 405).
+- Send text: PubNub publish after `GET /api/v3/instant-messaging/token`
+  (REST `…/messages` is 404). See `walla.account.chat.publish_text`.
 - Offers: `POST /api/v3/delivery/buyer/offers` with
   `{offer_id, offer_price_amount, offer_price_currency, item_ids}`.
-  `offer_id` is a client UUID. `item_ids` is a one-element list of the listing id.
+  Requires header `X-AppVersion` (without it Wallapop returns a generic HTTP 400).
+  Fixture: `fixtures/offer_buyer_request.json`. The old
+  `{item_id, amount, currency}` body returns **HTTP 400** — forbidden.
+  Some sellers disable offers → **409** `offer creation not allowed`; fall back to chat text.
 - Favorites: `/api/v3/users/me/favorites`, `/api/v3/items/{id}/favorite`
 
 Writes that fail closed as `error_type: unsupported` until fixtures exist.

walla_cli-0.1.7/fixtures/offer_buyer_request.json

@@ -0,0 +1,19 @@
+{
+  "schema_version": 1,
+  "path": "/api/v3/delivery/buyer/offers",
+  "method": "POST",
+  "required_keys": [
+    "offer_id",
+    "offer_price_amount",
+    "offer_price_currency",
+    "item_ids"
+  ],
+  "forbidden_keys": ["item_id", "amount", "currency"],
+  "example": {
+    "offer_id": "00000000-0000-4000-8000-000000000001",
+    "offer_price_amount": 650,
+    "offer_price_currency": "EUR",
+    "item_ids": ["wzv48vgrmdzl"]
+  },
+  "notes": "Old {item_id, amount, currency} returns HTTP 400. Never invent without this fixture."
+}

{walla_cli-0.1.6 → walla_cli-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "walla-cli"
-version = "0.1.6"
+version = "0.1.7"
 description = "Wallapop.es CLI - look · offer · talk for humans and agents"
 authors = [{ name = "Dr. Berend Gort", email = "berend.gort@gmail.com" }]
 readme = "README.md"

{walla_cli-0.1.6 → walla_cli-0.1.7}/scripts/check_code_quality.py

@@ -109,14 +109,67 @@ def check_layers() -> list[str]:
     return bad
 
 
+def check_offer_fixture() -> list[str]:
+    """Keep offer wire constants in sync with fixtures/offer_buyer_request.json."""
+    import json
+
+    wire = ROOT / "walla" / "account" / "offer_wire.py"
+    if not wire.is_file():
+        return ["walla/account/offer_wire.py missing"]
+    tree = ast.parse(wire.read_text(encoding="utf-8"))
+    consts: dict[str, tuple[str, ...]] = {}
+    for node in tree.body:
+        if not isinstance(node, ast.Assign) or len(node.targets) != 1:
+            continue
+        target = node.targets[0]
+        if not isinstance(target, ast.Name):
+            continue
+        if target.id not in ("REQUIRED_OFFER_KEYS", "FORBIDDEN_OFFER_KEYS"):
+            continue
+        if not isinstance(node.value, ast.Tuple):
+            continue
+        vals: list[str] = []
+        for elt in node.value.elts:
+            if isinstance(elt, ast.Constant) and isinstance(elt.value, str):
+                vals.append(elt.value)
+        consts[target.id] = tuple(vals)
+    required = consts.get("REQUIRED_OFFER_KEYS")
+    forbidden = consts.get("FORBIDDEN_OFFER_KEYS")
+    if not required or not forbidden:
+        return ["offer_wire.py missing REQUIRED/FORBIDDEN tuples"]
+    path = ROOT / "fixtures" / "offer_buyer_request.json"
+    if not path.is_file():
+        return ["fixtures/offer_buyer_request.json missing"]
+    meta = json.loads(path.read_text(encoding="utf-8"))
+    bad: list[str] = []
+    if tuple(meta.get("required_keys") or ()) != required:
+        bad.append("offer fixture required_keys != offer_wire.REQUIRED_OFFER_KEYS")
+    if tuple(meta.get("forbidden_keys") or ()) != forbidden:
+        bad.append("offer fixture forbidden_keys != offer_wire.FORBIDDEN_OFFER_KEYS")
+    example = meta.get("example") or {}
+    for k in forbidden:
+        if k in example:
+            bad.append(f"offer fixture example contains forbidden key {k}")
+    for k in required:
+        if k not in example:
+            bad.append(f"offer fixture example missing {k}")
+    return bad
+
+
 def main() -> int:
-    errors = check_loc() + check_emdash() + check_print() + check_layers()
+    errors = (
+        check_loc()
+        + check_emdash()
+        + check_print()
+        + check_layers()
+        + check_offer_fixture()
+    )
     if errors:
         print("FAILED code quality:")
         for e in errors:
             print(f"  {e}")
         return 1
-    print("OK: LOC<=250, no em-dash, no bare print, layer DAG")
+    print("OK: LOC<=250, no em-dash, no bare print, layer DAG, offer wire")
     return 0
 
 

{walla_cli-0.1.6 → walla_cli-0.1.7}/skills/walla/SKILL.md

@@ -36,7 +36,9 @@ walla setup --lat 41.39 --lon 2.17 --km 30 --budget 400 \
    every `https://es.wallapop.com/item/…` URL. Never summarize without links.
 3. One GRAB → `walla negotiate <id> --json`. Several GRABs → ask human to pick an id.
 4. Show opening + offer_eur + walk_away. Human approves text and EUR.
-5. Only then: `walla say … --yes` or `walla offer … --eur N --yes`
-6. **Stop.** Human pays or meets in the Wallapop app. `--yes` never means buy.
+5. Open chat if needed: `walla chat <item_id> --json` (listing Chat button).
+6. Only then: `walla say <item_id> "…" --yes` and/or `walla offer … --eur N --yes`
+   If offer returns 409 (seller disabled offers), put the EUR in the chat text.
+7. **Stop.** Human pays or meets in the Wallapop app. `--yes` never means buy.
 
 Reads and negotiate drafts are safe. Sends need confirm.

{walla_cli-0.1.6 → walla_cli-0.1.7}/tests/test_account.py

@@ -9,7 +9,7 @@ from unittest.mock import MagicMock, patch
 import pytest
 
 from walla.account.actions import quote_offer
-from walla.account.inbox import _extract_list, _extract_messages, list_conversations
+from walla.account.inbox import list_conversations, list_messages
 from walla.account.login import login_password
 from walla.core.exceptions import WallaAuthError, WallaUnsupportedError
 from walla.http.client import HttpClient
@@ -35,36 +35,33 @@ def test_quote_offer_totals(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) ->
     assert q.within_pickup is True
 
 
-def test_extract_conversations() -> None:
-    rows = _extract_list({"data": {"conversations": [{"id": "c1", "unread": 2}]}})
-    assert rows[0]["id"] == "c1"
-
-
-def test_extract_messages() -> None:
-    msgs = _extract_messages({"messages": [{"id": "m1", "text": "hola", "from_self": True}]})
-    assert msgs is not None
-    assert msgs[0].text == "hola"
-
-
-def test_list_conversations_mock() -> None:
+def test_list_conversations_bff_mock() -> None:
     class C(HttpClient):
         def request(self, method: str, path: str, **kwargs: Any) -> Any:  # type: ignore[override]
+            assert path == "/bff/messaging/inbox"
             return {
+                "user_hash": "me",
                 "conversations": [
                     {
-                        "id": "c1",
-                        "item": {"id": "i1", "title": "Bike"},
-                        "user": {"micro_name": "Ana"},
-                        "unread_count": 1,
-                        "last_message": {"text": "hola"},
+                        "hash": "c1",
+                        "item": {"hash": "i1", "title": "Bike"},
+                        "with_user": {"hash": "u2", "name": "Ana"},
+                        "unread_messages": 1,
+                        "channel": "chat.u2.c1.me",
+                        "messages": {
+                            "messages": [{"id": "m1", "text": "hola", "from_self": False}]
+                        },
                     }
-                ]
+                ],
             }
 
     with patch("walla.account.inbox._auth_client", return_value=C()):
         rows = list_conversations()
+        msgs = list_messages("c1")
     assert rows[0].id == "c1"
     assert rows[0].item_title == "Bike"
+    assert rows[0].other_user == "Ana"
+    assert msgs[0].text == "hola"
 
 
 def test_login_password_missing_args() -> None:

{walla_cli-0.1.6 → walla_cli-0.1.7}/tests/test_account_more.py

@@ -138,15 +138,34 @@ def test_list_messages_and_send() -> None:
 
     class C(HttpClient):
         def request(self, method: str, path: str, **kwargs: Any) -> Any:  # type: ignore[override]
-            if method == "GET":
-                return {"messages": [{"id": "1", "text": "hi"}]}
-            return {"ok": True}
+            if path == "/bff/messaging/inbox":
+                return {
+                    "user_hash": "me",
+                    "conversations": [
+                        {
+                            "hash": "c1",
+                            "item": {"hash": "i1", "title": "Bike"},
+                            "with_user": {"hash": "u2", "name": "Ana"},
+                            "channel": "chat.u2.c1.me",
+                            "messages": {
+                                "messages": [{"id": "1", "text": "hi", "from_self": False}]
+                            },
+                        }
+                    ],
+                }
+            if path == "/api/v3/instant-messaging/token":
+                return {"token": "pn-token"}
+            return {}
 
     with patch("walla.account.inbox._auth_client", return_value=C()):
-        msgs = list_messages("c1")
-        assert msgs[0].text == "hi"
-        out = send_message("c1", "hola", confirm=True)
-        assert out["sent"] is True
+        with patch("walla.account.chat._auth_client", return_value=C()):
+            with patch("walla.account.chat.requests.get") as pn:
+                pn.return_value = MagicMock(status_code=200, text="[1,\"Sent\",\"0\"]")
+                msgs = list_messages("c1")
+                assert msgs[0].text == "hi"
+                out = send_message("c1", "hola", confirm=True)
+                assert out["sent"] is True
+                assert pn.called
 
 
 def test_list_messages_unsupported() -> None:
@@ -154,11 +173,11 @@ def test_list_messages_unsupported() -> None:
 
     class C(HttpClient):
         def request(self, method: str, path: str, **kwargs: Any) -> Any:  # type: ignore[override]
-            raise RuntimeError("fail")
+            return {"user_hash": "me", "conversations": []}
 
     with patch("walla.account.inbox._auth_client", return_value=C()):
         with pytest.raises(WallaUnsupportedError):
-            list_messages("c1")
+            list_messages("missing")
 
 
 def test_watches_roundtrip(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:

walla_cli-0.1.7/tests/test_chat_open.py

@@ -0,0 +1,67 @@
+"""Chat open + offer-disabled regressions."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from walla.account.actions import make_offer
+from walla.account.chat import open_conversation
+from walla.http.headers import default_headers
+from walla.hunter.profile_store import save_profile
+from walla.models.listing import Listing, ListingLocation, Money
+from walla.models.profile import Profile
+
+
+def test_headers_include_app_version() -> None:
+    h = default_headers(device_id="d")
+    assert h["X-AppVersion"] == "825980"
+    assert "es-ES" in h["Accept-Language"]
+
+
+def test_open_conversation_posts_item_id() -> None:
+    client = MagicMock()
+    client.post.return_value = {
+        "conversation_id": "conv1",
+        "item_id": "item1",
+        "other_user_id": "user2",
+        "channel": "chat.user2.conv1.me",
+    }
+    out = open_conversation("item1", client=client)
+    assert out["conversation_id"] == "conv1"
+    assert out["channel"].startswith("chat.")
+    body = client.post.call_args.kwargs["json_body"]
+    assert body == {"item_id": "item1"}
+    assert "chat?itemId=item1" in out["chat_url"]
+
+
+def test_make_offer_409_points_to_say(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("WALLA_CONFIG_DIR", str(tmp_path))
+    save_profile(
+        Profile(lat=41.39, lon=2.17, pickup_km=50, budget=850),
+        path=tmp_path / "profile.json",
+    )
+    item = Listing(
+        id="wzv48vgrmdzl",
+        title="North Reach",
+        price=Money(amount=800, currency="EUR"),
+        web_slug="north-reach",
+        url="https://es.wallapop.com/item/north-reach",
+        shippable=True,
+        user_allows_shipping=True,
+        location=ListingLocation(latitude=39.5, longitude=2.7),
+    )
+    with patch("walla.account.actions.get_item", return_value=item):
+        with patch("walla.account.actions._auth_client") as auth:
+            client = MagicMock()
+            client.post.side_effect = RuntimeError(
+                'HTTP 409: [{"error_code":"offer creation not allowed"}]'
+            )
+            auth.return_value = client
+            with pytest.raises(Exception, match="walla say") as exc:
+                make_offer("wzv48vgrmdzl", 656, confirm=True)
+            assert "disabled" in str(exc.value).lower() or "409" in str(exc.value)

walla_cli-0.1.7/tests/test_regressions.py

@@ -0,0 +1,132 @@
+"""Regression locks for past agent/wire failures."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from walla.account.actions import make_offer
+from walla.account.offer_wire import (
+    FORBIDDEN_OFFER_KEYS,
+    REQUIRED_OFFER_KEYS,
+    assert_offer_body,
+    build_offer_body,
+)
+from walla.core.instruct import instruct_recipe
+from walla.hunter.negotiate import draft_negotiation
+from walla.hunter.profile_store import save_profile
+from walla.hunter.shortlist import PRESENT_RULE, rank_shortlist
+from walla.hunter.verdict import score_listing
+from walla.models.listing import Listing, ListingLocation, Money
+from walla.models.profile import Profile
+
+FIX = Path(__file__).resolve().parents[1] / "fixtures"
+
+
+def _listing(**kwargs: object) -> Listing:
+    base: dict[str, object] = dict(
+        id="wzv48vgrmdzl",
+        title="North Reach 13m 2023",
+        price=Money(amount=800, currency="EUR"),
+        web_slug="north-reach-13m-2023",
+        url="https://es.wallapop.com/item/north-reach-13m-2023",
+        shippable=True,
+        user_allows_shipping=True,
+        location=ListingLocation(latitude=39.53, longitude=2.72, city="Mallorca"),
+    )
+    base.update(kwargs)
+    return Listing(**base)  # type: ignore[arg-type]
+
+
+def test_offer_fixture_matches_builder() -> None:
+    meta = json.loads((FIX / "offer_buyer_request.json").read_text(encoding="utf-8"))
+    assert tuple(meta["required_keys"]) == REQUIRED_OFFER_KEYS
+    assert tuple(meta["forbidden_keys"]) == FORBIDDEN_OFFER_KEYS
+    assert_offer_body(meta["example"])
+    body = build_offer_body("wzv48vgrmdzl", 650, offer_id=meta["example"]["offer_id"])
+    assert set(body) == set(REQUIRED_OFFER_KEYS)
+    for k in FORBIDDEN_OFFER_KEYS:
+        assert k not in body
+
+
+def test_old_offer_shape_is_rejected() -> None:
+    with pytest.raises(ValueError, match="forbidden"):
+        assert_offer_body({"item_id": "x", "amount": 650, "currency": "EUR"})
+
+
+def test_make_offer_posts_fixture_shape(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("WALLA_CONFIG_DIR", str(tmp_path))
+    save_profile(
+        Profile(lat=41.39, lon=2.17, pickup_km=50, budget=850),
+        path=tmp_path / "profile.json",
+    )
+    with patch("walla.account.actions.get_item", return_value=_listing()):
+        with patch("walla.account.actions._auth_client") as auth:
+            client = MagicMock()
+            client.post.return_value = {"ok": True}
+            auth.return_value = client
+            out = make_offer("wzv48vgrmdzl", 650, confirm=True)
+            body = client.post.call_args.kwargs["json_body"]
+            assert_offer_body(body)
+            assert body["offer_price_amount"] == 650
+            assert out["offer_id"] == body["offer_id"]
+
+
+def test_fair_open_not_soft_90pct() -> None:
+    profile = Profile(lat=41.39, lon=2.17, km=30, pickup_km=30, budget=850)
+    brief = draft_negotiation(_listing(), profile)
+    assert brief.offer_eur == 656
+    assert brief.offer_eur < 800 * 0.90
+
+
+def test_shipping_draft_never_says_paso_hoy() -> None:
+    profile = Profile(lat=41.39, lon=2.17, km=30, pickup_km=30, budget=850)
+    brief = draft_negotiation(_listing(), profile)
+    blob = f"{brief.opening}\n{brief.offer_line}".lower()
+    assert "envío" in blob
+    assert "pasar hoy" not in blob
+    assert "recojo" not in blob
+
+
+def test_spain_default_keeps_far_shipping() -> None:
+    profile = Profile(lat=41.39, lon=2.17, km=30, budget=850)
+    far = _listing(price=Money(amount=700, currency="EUR"))
+    assert score_listing(far, profile) == "GRAB"
+    assert score_listing(far, profile, local=True) == "PASS"
+
+
+def test_shortlist_ranked_with_wallapop_links() -> None:
+    rows = [
+        {
+            "id": "a",
+            "title": "A",
+            "verdict": "LOOK",
+            "price": {"amount": 700},
+            "url": "https://es.wallapop.com/item/a",
+        },
+        {
+            "id": "b",
+            "title": "B",
+            "verdict": "GRAB",
+            "price": {"amount": 650},
+            "url": "https://es.wallapop.com/item/b",
+        },
+    ]
+    ranked = rank_shortlist(rows)
+    assert [r["id"] for r in ranked] == ["b", "a"]
+    assert all(r["url"].startswith("https://es.wallapop.com/item/") for r in ranked)
+    assert "markdown" in PRESENT_RULE.lower()
+
+
+def test_instruct_locks_present_and_spain(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("WALLA_CONFIG_DIR", str(tmp_path))
+    data = instruct_recipe()
+    assert data["present"]["channel"] == "wallapop.es"
+    assert "es.wallapop.com/item" in data["present"]["format"]
+    assert any("Spain" in r for r in data["rules"])
+    assert any("--local" in r for r in data["rules"])

{walla_cli-0.1.6 → walla_cli-0.1.7}/walla/__init__.py

@@ -4,4 +4,4 @@ from __future__ import annotations
 
 __all__ = ("__version__",)
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"

{walla_cli-0.1.6 → walla_cli-0.1.7}/walla/account/actions.py

@@ -2,10 +2,10 @@
 
 from __future__ import annotations
 
-import uuid
 from typing import Any
 
 from walla.account.login import ensure_access_token
+from walla.account.offer_wire import build_offer_body
 from walla.core.exceptions import WallaUnsupportedError
 from walla.http.client import HttpClient
 from walla.hunter.profile_store import load_profile
@@ -117,29 +117,28 @@ def make_offer(
             f"In-person listing outside pickup radius ({item.title}). Refuse offer."
         )
     http = client or _auth_client()
-    offer_id = str(uuid.uuid4())
+    body = build_offer_body(item_id, offer_eur)
     try:
         raw = http.post(
             "/api/v3/delivery/buyer/offers",
-            json_body={
-                "offer_id": offer_id,
-                "offer_price_amount": offer_eur,
-                "offer_price_currency": "EUR",
-                "item_ids": [item_id],
-            },
+            json_body=body,
             auth=True,
         )
         return {
             "sent": True,
-            "offer_id": offer_id,
+            "offer_id": body["offer_id"],
             "quote": quote.model_dump(mode="json"),
             "title": item.title,
             "response": raw,
         }
     except Exception as exc:
         msg = str(exc)
-        if "409" in msg:
-            raise WallaUnsupportedError("Seller disabled offers (409).") from exc
+        if "409" in msg or "offer creation not allowed" in msg.lower():
+            raise WallaUnsupportedError(
+                "Seller disabled formal offers (409). "
+                "Open chat and send the price in text: "
+                f'walla say {item_id} "… te propongo {offer_eur} € …" --yes'
+            ) from exc
         raise WallaUnsupportedError(
             f"Offer wire failed ({exc}). Capture POST buyer/offers and update WIRE.md."
         ) from exc

walla_cli-0.1.7/walla/account/chat.py

@@ -0,0 +1,136 @@
+"""Open chat (Chat button) and send via PubNub."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from typing import Any
+from urllib.parse import quote
+
+from curl_cffi import requests
+
+from walla.account.login import ensure_access_token
+from walla.core.exceptions import WallaUnsupportedError
+from walla.http.client import HttpClient
+from walla.http.headers import WEB_BASE, default_headers
+
+__all__ = (
+    "open_conversation",
+    "publish_text",
+    "resolve_conversation",
+)
+
+_PN_PUB = "pub-c-255dc549-86f5-4abd-8b9e-921d5a02fde7"
+_PN_SUB = "sub-c-89405e27-d4df-4d87-aca1-d6e9118f0a0d"
+_PN_ORIGIN = "https://ps2.pndsn.com"
+
+
+def _auth_client() -> HttpClient:
+    sess = ensure_access_token()
+    return HttpClient(access_token=sess.access_token, device_id=sess.device_id)
+
+
+def open_conversation(
+    item_id: str, *, client: HttpClient | None = None
+) -> dict[str, Any]:
+    """Same as the listing Chat button: create or reuse a conversation."""
+    http = client or _auth_client()
+    raw = http.post(
+        "/api/v3/conversations",
+        json_body={"item_id": item_id},
+        auth=True,
+    )
+    if not isinstance(raw, dict) or not raw.get("conversation_id"):
+        raise WallaUnsupportedError(
+            f"Chat open failed for {item_id}. Capture POST /api/v3/conversations."
+        )
+    return {
+        "conversation_id": str(raw["conversation_id"]),
+        "item_id": str(raw.get("item_id") or item_id),
+        "other_user_id": str(raw["other_user_id"]) if raw.get("other_user_id") else None,
+        "channel": str(raw["channel"]) if raw.get("channel") else None,
+        "chat_url": f"{WEB_BASE}/app/chat?itemId={item_id}",
+    }
+
+
+def resolve_conversation(
+    ref: str, *, client: HttpClient | None = None
+) -> dict[str, Any]:
+    """Resolve item id or conversation hash to an open conversation + channel."""
+    http = client or _auth_client()
+    from walla.account.inbox import list_conversations_raw
+
+    inbox = list_conversations_raw(client=http)
+    for row in inbox.get("conversations") or []:
+        if not isinstance(row, dict):
+            continue
+        cid = str(row.get("hash") or "")
+        item = row.get("item") or {}
+        item_hash = str(item.get("hash") or "") if isinstance(item, dict) else ""
+        if ref in (cid, item_hash):
+            with_user = row.get("with_user") or {}
+            return {
+                "conversation_id": cid,
+                "item_id": item_hash or None,
+                "other_user_id": (
+                    str(with_user.get("hash"))
+                    if isinstance(with_user, dict) and with_user.get("hash")
+                    else None
+                ),
+                "channel": str(row["channel"]) if row.get("channel") else None,
+                "user_hash": str(inbox.get("user_hash") or ""),
+                "chat_url": (
+                    f"{WEB_BASE}/app/chat?itemId={item_hash}" if item_hash else None
+                ),
+            }
+    opened = open_conversation(ref, client=http)
+    opened["user_hash"] = str(inbox.get("user_hash") or "")
+    return opened
+
+
+def publish_text(
+    *,
+    channel: str,
+    conversation_id: str,
+    from_user_hash: str,
+    to_user_hash: str,
+    text: str,
+    client: HttpClient | None = None,
+) -> dict[str, Any]:
+    """Publish a chat text via Wallapop PubNub (REST message POST is 404)."""
+    http = client or _auth_client()
+    token_raw = http.get("/api/v3/instant-messaging/token", auth=True)
+    if not isinstance(token_raw, dict) or not token_raw.get("token"):
+        raise WallaUnsupportedError("Missing instant-messaging token.")
+    pn_token = str(token_raw["token"])
+    msg_id = str(uuid.uuid4())
+    payload = json.dumps({"id": msg_id, "payload": {"text": text}})
+    meta = json.dumps(
+        {
+            "type": "text",
+            "sender": {"platform": {"app_version": "8.2616.0", "os_version": "0"}},
+            "to_user_hash": to_user_hash,
+            "from_user_hash": from_user_hash,
+            "conversation_hash": conversation_id,
+        }
+    )
+    url = (
+        f"{_PN_ORIGIN}/publish/{_PN_PUB}/{_PN_SUB}/0/{quote(channel, safe='')}/0/"
+        f"{quote(payload, safe='')}"
+        f"?meta={quote(meta, safe='')}"
+        f"&uuid={quote(from_user_hash, safe='')}"
+        f"&requestid={uuid.uuid4()}"
+        f"&pnsdk={quote('PubNub-JS-Web/10.2.6', safe='')}"
+        f"&auth={quote(pn_token, safe='')}"
+    )
+    headers = default_headers(device_id=getattr(http, "device_id", None))
+    headers["Accept"] = "*/*"
+    headers["Origin"] = WEB_BASE
+    headers["Referer"] = f"{WEB_BASE}/app/chat"
+    resp = requests.get(url, headers=headers, impersonate="chrome", timeout=30)
+    body = (resp.text or "").strip()
+    if resp.status_code != 200 or not body.startswith("[1,"):
+        raise WallaUnsupportedError(
+            f"PubNub publish failed ({resp.status_code}): {body[:200]}"
+        )
+    return {"sent": True, "message_id": msg_id, "conversation_id": conversation_id}