agentstr 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

agentstr/{marketplace.py → merchant.py}

@@ -1,296 +1,36 @@
-import ast
+"""
+Module implementing the MerchantTools Toolkit for Agno agents.
+"""
+
 import json
 import logging
-import re
-from typing import Any, Dict, List, Optional, Tuple, Union, cast
-
-from agentstr.nostr import (
-    EventId,
-    Keys,
-    NostrClient,
-    ProductData,
-    ShippingCost,
-    ShippingMethod,
-    StallData,
-)
-
-try:
-    from phi.tools import Toolkit
-except ImportError:
-    raise ImportError(
-        "`phidata` not installed. Please install using `pip install phidata`"
-    )
-
-from pydantic import BaseModel, ConfigDict, Field, validate_call
-
-
-class Profile:
-
-    logger = logging.getLogger("Profile")
-    WEB_URL: str = "https://primal.net/p/"
-
-    def __init__(self, name: str, about: str, picture: str, nsec: Optional[str] = None):
-        """Initialize the profile.
-
-        Args:
-            name: Name for the merchant
-            about: brief description about the merchant
-            picture: url to a png file with a picture for the merchant
-            nsec: optional private key to be used by this Merchant
-        """
-
-        # Set log handling for MerchantProfile
-        if not Profile.logger.hasHandlers():
-            console_handler = logging.StreamHandler()
-            console_handler.setLevel(logging.INFO)
-            formatter = logging.Formatter(
-                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-            )
-            console_handler.setFormatter(formatter)
-            Profile.logger.addHandler(console_handler)
-
-        self.name = name
-        self.about = about
-        self.picture = picture
-
-        if nsec:
-            self.private_key = nsec
-            keys = Keys.parse(self.private_key)
-            self.public_key = keys.public_key().to_bech32()
-            Profile.logger.info(
-                f"Pre-defined private key reused for {self.name}: {self.private_key}"
-            )
-            Profile.logger.info(
-                f"Pre-defined public key reused for {self.name}: {self.public_key}"
-            )
-        else:
-            keys = Keys.generate()
-            self.private_key = keys.secret_key().to_bech32()
-            self.public_key = keys.public_key().to_bech32()
-            Profile.logger.info(
-                f"New private key created for {self.name}: {self.private_key}"
-            )
-            Profile.logger.info(
-                f"New public key created for {self.name}: {self.public_key}"
-            )
-
-        self.url = str(self.WEB_URL) + str(self.public_key)
-
-    def __str__(self) -> str:
-        return (
-            "Merchant Profile:\n"
-            "Name = {}\n"
-            "Description = {}\n"
-            "Picture = {}\n"
-            "URL = {}\n"
-            "Private key = {}\n"
-            "Public key = {}".format(
-                self.name,
-                self.about,
-                self.picture,
-                self.url,
-                self.private_key,
-                self.public_key,
-            )
-        )
-
-    def to_dict(self) -> dict:
-        return {
-            "name": self.name,
-            "description": self.about,
-            "picture": self.picture,
-            "public key": self.public_key,
-            "private key": self.private_key,
-        }
-
-    def get_about(self) -> str:
-        """
-        Returns a description of the Merchant
-
-        Returns:
-            str: description of the Merchant
-        """
-        return self.about
-
-    def get_name(self) -> str:
-        """
-        Returns the Merchant's name
-
-        Returns:
-            str: Merchant's name
-        """
-        return self.name
-
-    def get_picture(self) -> str:
-        """
-        Returns the picture associated with the Merchant.
-
-        Returns:
-            str: URL to the picture associated with the Merchant
-        """
-        return self.picture
-
-    def get_private_key(self) -> str:
-        """
-        Returns the private key.
-
-        Returns:
-            str: private key in bech32 format
-        """
-        return str(self.private_key)
-
-    def get_public_key(self) -> str:
-        """
-        Returns the public key.
-
-        Returns:
-            str: public key in bech32 format
-        """
-        return str(self.public_key)
-
-    def get_url(self) -> str:
-        return str(self.url)
-
-
-class MerchantProduct(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    id: str
-    stall_id: str
-    name: str
-    description: str
-    images: List[str]
-    currency: str
-    price: float
-    quantity: int
-    shipping: List[ShippingCost]
-    categories: Optional[List[str]] = []
-    specs: Optional[List[List[str]]] = []
-
-    @classmethod
-    def from_product_data(cls, product: ProductData) -> "MerchantProduct":
-        return cls(
-            id=product.id,
-            stall_id=product.stall_id,
-            name=product.name,
-            description=product.description,
-            images=product.images,
-            currency=product.currency,
-            price=product.price,
-            quantity=product.quantity,
-            shipping=product.shipping,
-            categories=product.categories if product.categories is not None else [],
-            specs=product.specs if product.specs is not None else [],
-        )
-
-    def to_product_data(self) -> ProductData:
-        return ProductData(
-            id=self.id,
-            stall_id=self.stall_id,
-            name=self.name,
-            description=self.description,
-            images=self.images,
-            currency=self.currency,
-            price=self.price,
-            quantity=self.quantity,
-            shipping=self.shipping,
-            categories=self.categories,
-            specs=self.specs,
-        )
-
-    def to_dict(self) -> dict:
-        """
-        Returns a dictionary representation of the MerchantProduct.
-        ShippingCost class is not serializable, so we need to convert it to a dictionary.
-
-        Returns:
-            dict: dictionary representation of the MerchantProduct
-        """
-        shipping_dicts = []
-        for shipping in self.shipping:
-            shipping_dicts.append({"id": shipping.id, "cost": shipping.cost})
-
-        return {
-            "id": self.id,
-            "stall_id": self.stall_id,
-            "name": self.name,
-            "description": self.description,
-            "images": self.images,
-            "currency": self.currency,
-            "price": self.price,
-            "quantity": self.quantity,
-            "shipping": shipping_dicts,
-            "categories": self.categories,
-            "specs": self.specs,
-        }
-
-
-class MerchantStall(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    id: str
-    name: str
-    description: str
-    currency: str
-    shipping: List[ShippingMethod]
-
-    @classmethod
-    def from_stall_data(cls, stall: StallData) -> "MerchantStall":
-        return cls(
-            id=stall.id(),
-            name=stall.name(),
-            description=stall.description(),
-            currency=stall.currency(),
-            shipping=stall.shipping(),
-        )
-
-    def to_stall_data(self) -> StallData:
-        return StallData(
-            self.id,
-            self.name,
-            self.description,
-            self.currency,
-            self.shipping,  # No conversion needed
-        )
+import time
+from typing import Any, List, Optional, Tuple, Union
 
-    def to_dict(self) -> dict:
-        """
-        Returns a dictionary representation of the MerchantStall.
-        ShippingMethod class is not serializable, so we need to convert it to a dictionary.
-        We can only access cost and id from the ShippingMethod class. We can't access name or regions.
+from pydantic import ConfigDict
 
-        Returns:
-            dict: dictionary representation of the MerchantStall
-        """
-        shipping_dicts = []
-        for shipping in self.shipping:
-            shipping_dicts.append(
-                {
-                    "cost": shipping.get_shipping_cost().cost,
-                    "id": shipping.get_shipping_cost().id,
-                }
-            )
+from agentstr.models import AgentProfile, MerchantProduct, MerchantStall
+from agentstr.nostr import EventId, NostrClient
 
-        return {
-            "id": self.id,
-            "name": self.name,
-            "description": self.description,
-            "currency": self.currency,
-            "shipping zones": [shipping_dicts],
-        }
+try:
+    from agno.tools import Toolkit
+except ImportError as exc:
+    raise ImportError(
+        "`agno` not installed. Please install using `pip install agno`"
+    ) from exc
 
 
-class Merchant(Toolkit):
+class MerchantTools(Toolkit):
     """
-    Merchant is a toolkit that allows a merchant to publish products and stalls to Nostr.
+    MerchantTools is a toolkit that allows a merchant to publish
+    products and stalls to Nostr.
 
     TBD:
-    - Better differentiation between products and stalls in the database and products and stalls published.
+    - Better differentiation between products and stalls in the database
+    and products and stalls published.
 
     """
 
-    from pydantic import ConfigDict
-
     model_config = ConfigDict(
         arbitrary_types_allowed=True, extra="allow", validate_assignment=True
     )
@@ -301,7 +41,7 @@ class Merchant(Toolkit):
 
     def __init__(
         self,
-        merchant_profile: Profile,
+        merchant_profile: AgentProfile,
         relay: str,
         stalls: List[MerchantStall],
         products: List[MerchantProduct],
@@ -317,9 +57,7 @@ class Merchant(Toolkit):
         super().__init__(name="merchant")
         self.relay = relay
         self.merchant_profile = merchant_profile
-        self._nostr_client = NostrClient(
-            self.relay, self.merchant_profile.get_private_key()
-        )
+        self._nostr_client = NostrClient(relay, merchant_profile.get_private_key())
 
         # initialize the Product DB with no event id
         self.product_db = [(product, None) for product in products]
@@ -327,7 +65,7 @@ class Merchant(Toolkit):
         # initialize the Stall DB with no event id
         self.stall_db = [(stall, None) for stall in stalls]
 
-        # Register wrapped versions of the methods
+        # Register methods
         self.register(self.get_profile)
         self.register(self.get_relay)
         self.register(self.get_products)
@@ -345,21 +83,33 @@ class Merchant(Toolkit):
         self.register(self.remove_product_by_name)
         self.register(self.remove_stall_by_name)
 
+    def get_nostr_client(self) -> NostrClient:
+        """
+        Get the NostrClient instance
+        """
+        return self._nostr_client
+
     def get_profile(self) -> str:
         """
-        Retrieves merchant profile in JSON format
+        Get the merchant profile in JSON format
 
         Returns:
             str: merchant profile in JSON format
         """
-        return json.dumps(self.merchant_profile.to_dict())
+        return json.dumps(self.merchant_profile.to_json())
 
     def get_relay(self) -> str:
+        """
+        Get the Nostr relay the merchant is using
+
+        Returns:
+            str: Nostr relay
+        """
         return self.relay
 
     def get_products(self) -> str:
         """
-        Retrieves all the merchant products
+        Get all the merchant products
 
         Returns:
             str: JSON string containing all products
@@ -368,7 +118,7 @@ class Merchant(Toolkit):
 
     def get_stalls(self) -> str:
         """
-        Retrieves all the merchant stalls in JSON format
+        Get all the merchant stalls in JSON format
 
         Returns:
             str: JSON string containing all stalls
@@ -379,10 +129,13 @@ class Merchant(Toolkit):
         self,
     ) -> str:
         """
-        Publishes or updates all products in the Merchant's Product DB
+        Publishes or updates to Nostrall products in the Merchant's Product DB
 
         Returns:
             str: JSON array with status of all product publishing operations
+
+        Raises:
+            ValueError: if NostrClient is not initialized
         """
 
         if self._nostr_client is None:
@@ -393,9 +146,9 @@ class Merchant(Toolkit):
         for i, (product, _) in enumerate(self.product_db):
             try:
                 # Convert MerchantProduct to ProductData for nostr_client
-                product_data = product.to_product_data()
+                # product_data = product.to_product_data()
                 # Publish using the SDK's synchronous method
-                event_id = self._nostr_client.publish_product(product_data)
+                event_id = self._nostr_client.publish_product(product)
                 self.product_db[i] = (product, event_id)
                 results.append(
                     {
@@ -404,8 +157,10 @@ class Merchant(Toolkit):
                         "product_name": product.name,
                     }
                 )
-            except Exception as e:
-                Profile.logger.error(f"Unable to publish product {product}. Error {e}")
+                # Pause for 0.5 seconds to avoid rate limiting
+                time.sleep(0.5)
+            except RuntimeError as e:
+                logging.error("Unable to publish product %s. Error %s", product, e)
                 results.append(
                     {"status": "error", "message": str(e), "product_name": product.name}
                 )
@@ -416,10 +171,14 @@ class Merchant(Toolkit):
         self,
     ) -> str:
         """
-        Publishes or updates all stalls managed by the merchant and adds the corresponding EventId to the Stall DB
+        Publishes or updates to Nostr all stalls managed by the merchant and adds
+        the corresponding EventId to the Stall DB
 
         Returns:
             str: JSON array with status of all stall publishing operations
+
+        Raises:
+            ValueError: if NostrClient is not initialized
         """
         if self._nostr_client is None:
             raise ValueError("NostrClient not initialized")
@@ -427,9 +186,9 @@ class Merchant(Toolkit):
 
         for i, (stall, _) in enumerate(self.stall_db):
             try:
-                # Convert MerchantStall to StallData for nostr_client
-                stall_data = stall.to_stall_data()
-                event_id = self._nostr_client.publish_stall(stall_data)
+                # We don't need to convert MerchantStall to StallData for nostr_client
+                # stall_data = stall.to_stall_data()
+                event_id = self._nostr_client.publish_stall(stall)
                 self.stall_db[i] = (stall, event_id)
                 results.append(
                     {
@@ -438,8 +197,10 @@ class Merchant(Toolkit):
                         "stall_name": stall.name,
                     }
                 )
-            except Exception as e:
-                Profile.logger.error(f"Unable to publish stall {stall}. Error {e}")
+                # Pause for 0.5 seconds to avoid rate limiting
+                time.sleep(0.5)
+            except RuntimeError as e:
+                logging.error("Unable to publish stall %s. Error %s", stall, e)
                 results.append(
                     {"status": "error", "message": str(e), "stall_name": stall.name}
                 )
@@ -448,13 +209,17 @@ class Merchant(Toolkit):
 
     def publish_new_product(self, product: MerchantProduct) -> str:
         """
-        Publishes a new product that is not currently in the Merchant's Product DB and adds it to the Product DB
+        Publishes to Nostra new product that is not currently in the Merchant's
+        Product DB and adds it to the Product DB
 
         Args:
             product: MerchantProduct to be published
 
         Returns:
             str: JSON string with status of the operation
+
+        Raises:
+            ValueError: if NostrClient is not initialized
         """
         if self._nostr_client is None:
             raise ValueError("NostrClient not initialized")
@@ -473,19 +238,23 @@ class Merchant(Toolkit):
                     "product_name": product.name,
                 }
             )
-        except Exception as e:
+        except RuntimeError as e:
             return json.dumps(
                 {"status": "error", "message": str(e), "product_name": product.name}
             )
 
     def publish_product_by_name(self, arguments: str) -> str:
         """
-        Publishes or updates a given product from the Merchant's Product DB
+        Publishes or updates to Nostra given product from the Merchant's Product DB
         Args:
-            arguments: JSON string that may contain {"name": "product_name"} or just "product_name"
+            arguments: JSON string that may contain
+            {"name": "product_name"} or just "product_name"
 
         Returns:
             str: JSON string with status of the operation
+
+        Raises:
+            ValueError: if NostrClient is not initialized
         """
         if self._nostr_client is None:
             raise ValueError("NostrClient not initialized")
@@ -508,11 +277,13 @@ class Merchant(Toolkit):
             if product.name == name:
                 try:
                     # Convert MerchantProduct to ProductData for nostr_client
-                    product_data = product.to_product_data()
+                    # product_data = product.to_product_data()
                     # Publish using the SDK's synchronous method
-                    event_id = self._nostr_client.publish_product(product_data)
+                    event_id = self._nostr_client.publish_product(product)
                     # Update the product_db with the new event_id
                     self.product_db[i] = (product, event_id)
+                    # Pause for 0.5 seconds to avoid rate limiting
+                    time.sleep(0.5)
                     return json.dumps(
                         {
                             "status": "success",
@@ -520,7 +291,7 @@ class Merchant(Toolkit):
                             "product_name": product.name,
                         }
                     )
-                except Exception as e:
+                except RuntimeError as e:
                     return json.dumps(
                         {
                             "status": "error",
@@ -540,7 +311,7 @@ class Merchant(Toolkit):
 
     def publish_products_by_stall_name(self, arguments: Union[str, dict]) -> str:
         """
-        Publishes or updates all products sold by the merchant in a given stall
+        Publishes or updates to Nostr all products sold by the merchant in a given stall
 
         Args:
             arguments: str or dict with the stall name. Can be in formats:
@@ -550,6 +321,9 @@ class Merchant(Toolkit):
 
         Returns:
             str: JSON array with status of all product publishing operations
+
+        Raises:
+            ValueError: if NostrClient is not initialized
         """
         if self._nostr_client is None:
             raise ValueError("NostrClient not initialized")
@@ -604,8 +378,8 @@ class Merchant(Toolkit):
             for i, (product, _) in enumerate(self.product_db):
                 if product.stall_id == stall_id:
                     try:
-                        product_data = product.to_product_data()
-                        event_id = self._nostr_client.publish_product(product_data)
+                        # product_data = product.to_product_data()
+                        event_id = self._nostr_client.publish_product(product)
                         self.product_db[i] = (product, event_id)
                         results.append(
                             {
@@ -615,7 +389,9 @@ class Merchant(Toolkit):
                                 "stall_name": stall_name,
                             }
                         )
-                    except Exception as e:
+                        # Pause for 0.5 seconds to avoid rate limiting
+                        time.sleep(0.5)
+                    except RuntimeError as e:
                         results.append(
                             {
                                 "status": "error",
@@ -638,14 +414,14 @@ class Merchant(Toolkit):
 
             return json.dumps(results)
 
-        except Exception as e:
+        except RuntimeError as e:
             return json.dumps(
                 [{"status": "error", "message": str(e), "arguments": str(arguments)}]
             )
 
     def publish_profile(self) -> str:
         """
-        Publishes the profile on Nostr
+        Publishes the profile to Nostr
 
         Returns:
             str: JSON of the event that published the profile
@@ -663,27 +439,32 @@ class Merchant(Toolkit):
                 self.merchant_profile.get_picture(),
             )
             return json.dumps(event_id.__dict__)
-        except Exception as e:
-            raise RuntimeError(f"Unable to publish the profile: {e}")
+        except RuntimeError as e:
+            raise RuntimeError(f"Unable to publish the profile: {e}") from e
 
     def publish_new_stall(self, stall: MerchantStall) -> str:
         """
-        Publishes a new stall that is not currently in the Merchant's Stall DB and adds it to the Stall DB
+        Publishes to Nostr a new stall that is not currently in the Merchant's
+        Stall DB and adds it to the Stall DB
 
         Args:
             stall: MerchantStall to be published
 
         Returns:
             str: JSON string with status of the operation
+
+        Raises:
+            ValueError: if NostrClient is not initialized
         """
         if self._nostr_client is None:
             raise ValueError("NostrClient not initialized")
 
         try:
-            # Convert to StallData for SDK
-            stall_data = stall.to_stall_data()
-            # Publish using the SDK's synchronous method
-            event_id = self._nostr_client.publish_stall(stall_data)
+            # We don't ned to convert to StallData.
+            # nostr_client.publish_stall() accepts a MerchantStall
+            # stall_data = stall.to_stall_data()
+            # Publish using the  synchronous method
+            event_id = self._nostr_client.publish_stall(stall)
             # we need to add the stall event id to the stall db
             self.stall_db.append((stall, event_id))
             return json.dumps(
@@ -693,12 +474,27 @@ class Merchant(Toolkit):
                     "stall_name": stall.name,
                 }
             )
-        except Exception as e:
+        except RuntimeError as e:
             return json.dumps(
                 {"status": "error", "message": str(e), "stall_name": stall.name}
             )
 
     def publish_stall_by_name(self, arguments: Union[str, dict]) -> str:
+        """
+        Publishes or updates to Nostr a given stall by name
+
+        Args:
+            arguments: str or dict with the stall name. Can be in formats:
+                - {"name": "stall_name"}
+                - {"arguments": "{\"name\": \"stall_name\"}"}
+                - "stall_name"
+
+        Returns:
+            str: JSON array with status of the operation
+
+        Raises:
+            ValueError: if NostrClient is not initialized
+        """
         if self._nostr_client is None:
             raise ValueError("NostrClient not initialized")
 
@@ -735,9 +531,10 @@ class Merchant(Toolkit):
             for i, (stall, _) in enumerate(self.stall_db):
                 if stall.name == stall_name:
                     try:
-                        stall_data = stall.to_stall_data()
-                        event_id = self._nostr_client.publish_stall(stall_data)
+                        event_id = self._nostr_client.publish_stall(stall)
                         self.stall_db[i] = (stall, event_id)
+                        # Pause for 0.5 seconds to avoid rate limiting
+                        time.sleep(0.5)
                         return json.dumps(
                             {
                                 "status": "success",
@@ -745,7 +542,8 @@ class Merchant(Toolkit):
                                 "stall_name": stall.name,
                             }
                         )
-                    except Exception as e:
+
+                    except RuntimeError as e:
                         return json.dumps(
                             [
                                 {
@@ -767,17 +565,20 @@ class Merchant(Toolkit):
                 ]
             )
 
-        except Exception as e:
+        except RuntimeError as e:
             return json.dumps(
                 [{"status": "error", "message": str(e), "stall_name": "unknown"}]
             )
 
     def remove_all_products(self) -> str:
         """
-        Removes all published products from Nostr
+        Removes from Nostr all products published by the merchant
 
         Returns:
             str: JSON array with status of all product removal operations
+
+        Raises:
+            ValueError: if NostrClient is not initialized
         """
         if self._nostr_client is None:
             raise ValueError("NostrClient not initialized")
@@ -789,7 +590,9 @@ class Merchant(Toolkit):
                 results.append(
                     {
                         "status": "skipped",
-                        "message": f"Product '{product.name}' has not been published yet",
+                        "message": (
+                            f"Product '{product.name}' has not been published yet"
+                        ),
                         "product_name": product.name,
                     }
                 )
@@ -810,7 +613,9 @@ class Merchant(Toolkit):
                         "event_id": str(event_id),
                     }
                 )
-            except Exception as e:
+                # Pause for 0.5 seconds to avoid rate limiting
+                time.sleep(0.5)
+            except RuntimeError as e:
                 results.append(
                     {"status": "error", "message": str(e), "product_name": product.name}
                 )
@@ -819,10 +624,14 @@ class Merchant(Toolkit):
 
     def remove_all_stalls(self) -> str:
         """
-        Removes all stalls and their products from Nostr
+        Removes from Nostr all stalls from the merchant and their
+        corresponding products
 
         Returns:
             str: JSON array with status of all removal operations
+
+        Raises:
+            ValueError: if NostrClient is not initialized
         """
         if self._nostr_client is None:
             raise ValueError("NostrClient not initialized")
@@ -841,7 +650,7 @@ class Merchant(Toolkit):
                         results.append(
                             {
                                 "status": "skipped",
-                                "message": f"Product '{product.name}' has not been published yet",
+                                "message": "Unpublished product",
                                 "product_name": product.name,
                                 "stall_name": stall_name,
                             }
@@ -863,7 +672,7 @@ class Merchant(Toolkit):
                                 "event_id": str(event_id),
                             }
                         )
-                    except Exception as e:
+                    except RuntimeError as e:
                         results.append(
                             {
                                 "status": "error",
@@ -879,7 +688,7 @@ class Merchant(Toolkit):
                 results.append(
                     {
                         "status": "skipped",
-                        "message": f"Stall '{stall_name}' has not been published yet",
+                        "message": (f"Stall '{stall_name}' has not been published yet"),
                         "stall_name": stall_name,
                     }
                 )
@@ -897,7 +706,9 @@ class Merchant(Toolkit):
                             "event_id": str(stall_event_id),
                         }
                     )
-                except Exception as e:
+                    # Pause for 0.5 seconds to avoid rate limiting
+                    time.sleep(0.5)
+                except RuntimeError as e:
                     results.append(
                         {"status": "error", "message": str(e), "stall_name": stall_name}
                     )
@@ -906,13 +717,17 @@ class Merchant(Toolkit):
 
     def remove_product_by_name(self, arguments: str) -> str:
         """
-        Deletes a product with the given name from Nostr
+        Removes from Nostr a product with the given name
 
         Args:
-            arguments: JSON string that may contain {"name": "product_name"} or just "product_name"
+            arguments: JSON string that may contain {"name": "product_name"}
+            or just "product_name"
 
         Returns:
             str: JSON string with status of the operation
+
+        Raises:
+            ValueError: if NostrClient is not initialized
         """
         if self._nostr_client is None:
             raise ValueError("NostrClient not initialized")
@@ -949,6 +764,8 @@ class Merchant(Toolkit):
                     )
                     # Remove the event_id, keeping the product in the database
                     self.product_db[i] = (product, None)
+                    # Pause for 0.5 seconds to avoid rate limiting
+                    time.sleep(0.5)
                     return json.dumps(
                         {
                             "status": "success",
@@ -957,7 +774,7 @@ class Merchant(Toolkit):
                             "event_id": str(event_id),
                         }
                     )
-                except Exception as e:
+                except RuntimeError as e:
                     return json.dumps(
                         {"status": "error", "message": str(e), "product_name": name}
                     )
@@ -972,7 +789,8 @@ class Merchant(Toolkit):
         )
 
     def remove_stall_by_name(self, arguments: Union[str, dict]) -> str:
-        """Remove a stall and its products by name
+        """
+        Remove from Nostr a stall and its products by name
 
         Args:
             arguments: str or dict with the stall name. Can be in formats:
@@ -982,6 +800,9 @@ class Merchant(Toolkit):
 
         Returns:
             str: JSON array with status of the operation
+
+        Raises:
+            ValueError: if NostrClient is not initialized
         """
         if self._nostr_client is None:
             raise ValueError("NostrClient not initialized")
@@ -1042,7 +863,7 @@ class Merchant(Toolkit):
                         results.append(
                             {
                                 "status": "skipped",
-                                "message": f"Product '{product.name}' has not been published yet",
+                                "message": "Unpublished product",
                                 "product_name": product.name,
                                 "stall_name": stall_name,
                             }
@@ -1063,7 +884,9 @@ class Merchant(Toolkit):
                                 "event_id": str(event_id),
                             }
                         )
-                    except Exception as e:
+                        # Pause for 0.5 seconds to avoid rate limiting
+                        time.sleep(0.5)
+                    except RuntimeError as e:
                         results.append(
                             {
                                 "status": "error",
@@ -1080,7 +903,9 @@ class Merchant(Toolkit):
                     results.append(
                         {
                             "status": "skipped",
-                            "message": f"Stall '{stall_name}' has not been published yet",
+                            "message": (
+                                f"Stall '{stall_name}' has not been published yet"
+                            ),
                             "stall_name": stall_name,
                         }
                     )
@@ -1101,7 +926,7 @@ class Merchant(Toolkit):
                                 "event_id": str(stall_event_id),
                             }
                         )
-                    except Exception as e:
+                    except RuntimeError as e:
                         results.append(
                             {
                                 "status": "error",
@@ -1112,20 +937,7 @@ class Merchant(Toolkit):
 
             return json.dumps(results)
 
-        except Exception as e:
+        except RuntimeError as e:
             return json.dumps(
                 [{"status": "error", "message": str(e), "stall_name": "unknown"}]
             )
-
-    def get_event_id(self, response: Any) -> str:
-        """Convert any response to a string event ID.
-
-        Args:
-            response: Response that might contain an event ID
-
-        Returns:
-            str: String representation of event ID or empty string if None
-        """
-        if response is None:
-            return ""
-        return str(response)