ai-lls-lib 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

ai_lls_lib/payment/stripe_manager.py

@@ -0,0 +1,473 @@
+"""Stripe API management with metadata conventions."""
+
+import os
+from typing import List, Optional, Dict, Any
+import logging
+
+try:
+    import stripe
+except ImportError:
+    stripe = None  # Handle gracefully for testing
+
+from .models import Plan
+
+logger = logging.getLogger(__name__)
+
+
+class StripeManager:
+    """
+    Manages Stripe resources with metadata conventions.
+    Uses metadata to discover and filter products/prices.
+    """
+
+    METADATA_SCHEMA = {
+        "product_type": "landline_scrubber",
+        "environment": None,  # Set at runtime
+        "tier": None,
+        "credits": None,
+        "active": "true"
+    }
+
+    def __init__(self, api_key: Optional[str] = None, environment: Optional[str] = None):
+        """Initialize with Stripe API key and environment."""
+        if not stripe:
+            raise ImportError("stripe package not installed. Run: pip install stripe")
+
+        self.api_key = api_key or os.environ.get("STRIPE_SECRET_KEY")
+        if not self.api_key:
+            raise ValueError("Stripe API key not provided and STRIPE_SECRET_KEY not set")
+
+        stripe.api_key = self.api_key
+        self.environment = environment or os.environ.get("ENVIRONMENT", "staging")
+
+    def list_plans(self) -> List[Plan]:
+        """
+        Fetch active plans from Stripe using metadata.
+        Returns list of Plan objects sorted by price.
+        """
+        try:
+            # Fetch all active prices with expanded product data
+            prices = stripe.Price.list(
+                active=True,
+                expand=["data.product"],
+                limit=100
+            )
+
+            plans = []
+            for price in prices.data:
+                metadata = price.metadata or {}
+
+                # Filter by our metadata conventions
+                if (metadata.get("product_type") == "landline_scrubber" and
+                    metadata.get("environment") == self.environment and
+                    metadata.get("active") == "true"):
+
+                    # Convert to Plan object
+                    plan = Plan.from_stripe_price(price, price.product)
+                    plans.append(plan)
+
+            # Sort by price amount
+            plans.sort(key=lambda p: p.plan_amount)
+
+            logger.info(f"Found {len(plans)} active plans for environment {self.environment}")
+            return plans
+
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error listing plans: {e}")
+            # Return mock data for development/testing
+            return self._get_mock_plans()
+
+    def create_setup_intent(self, user_id: str) -> Dict[str, str]:
+        """
+        Create a SetupIntent for secure payment method collection.
+        Frontend will confirm this with Stripe Elements.
+        """
+        try:
+            # Get or create customer
+            customer = self._get_or_create_customer(user_id)
+
+            # Create SetupIntent
+            setup_intent = stripe.SetupIntent.create(
+                customer=customer.id,
+                metadata={
+                    "user_id": user_id,
+                    "environment": self.environment
+                }
+            )
+
+            return {
+                "client_secret": setup_intent.client_secret,
+                "setup_intent_id": setup_intent.id
+            }
+
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error creating setup intent: {e}")
+            raise
+
+    def attach_payment_method(self, user_id: str, payment_method_id: str, billing_details: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Attach a payment method to customer (legacy path).
+        Returns whether this is the first card.
+        """
+        try:
+            # Get or create customer
+            customer = self._get_or_create_customer(user_id)
+
+            # Attach payment method to customer
+            payment_method = stripe.PaymentMethod.attach(
+                payment_method_id,
+                customer=customer.id
+            )
+
+            # Update billing details if provided
+            if billing_details:
+                stripe.PaymentMethod.modify(
+                    payment_method_id,
+                    billing_details=billing_details
+                )
+
+            # Check if this is the first payment method
+            payment_methods = stripe.PaymentMethod.list(
+                customer=customer.id,
+                type="card"
+            )
+
+            first_card = len(payment_methods.data) == 1
+
+            # Set as default if first card
+            if first_card:
+                stripe.Customer.modify(
+                    customer.id,
+                    invoice_settings={"default_payment_method": payment_method_id}
+                )
+
+            return {
+                "payment_method_id": payment_method_id,
+                "first_card": first_card,
+                "customer_id": customer.id
+            }
+
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error attaching payment method: {e}")
+            raise
+
+    def verify_payment_method(self, user_id: str, payment_method_id: str) -> Dict[str, Any]:
+        """
+        Perform $1 verification charge on new payment method.
+        """
+        try:
+            customer = self._get_or_create_customer(user_id)
+
+            # Create $1 verification charge
+            payment_intent = stripe.PaymentIntent.create(
+                amount=100,  # $1.00 in cents
+                currency="usd",
+                customer=customer.id,
+                payment_method=payment_method_id,
+                off_session=True,
+                confirm=True,
+                description="Card verification - $1 charge",
+                metadata={
+                    "user_id": user_id,
+                    "type": "verification",
+                    "environment": self.environment
+                }
+            )
+
+            return {
+                "status": payment_intent.status,
+                "payment_intent_id": payment_intent.id
+            }
+
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error verifying payment method: {e}")
+            raise
+
+    def charge_prepaid(self, user_id: str, reference_code: str, amount: Optional[float] = None) -> Dict[str, Any]:
+        """
+        Charge saved payment method for credit purchase.
+        Supports both fixed-price and legacy variable-amount plans.
+        """
+        try:
+            customer = self._get_or_create_customer(user_id)
+
+            # Legacy variable-amount plan references
+            VARIABLE_AMOUNT_REFS = ["79541679412215", "79541679412216"]
+
+            if reference_code in VARIABLE_AMOUNT_REFS:
+                # Variable amount plan - validate amount
+                if not amount:
+                    raise ValueError("Amount required for variable-amount plan")
+
+                # Validate amount against allowed values from metadata
+                # For now, allow common amounts
+                allowed_amounts = [5, 10, 20, 25, 50, 75, 100, 150, 200, 250, 500]
+                if amount not in allowed_amounts:
+                    raise ValueError(f"Invalid amount ${amount}. Allowed amounts: {allowed_amounts}")
+
+                # Calculate credits based on tier
+                if reference_code == "79541679412215":  # STANDARD
+                    credits_per_dollar = 500
+                else:  # POWER
+                    credits_per_dollar = 570
+
+                credits_to_add = int(amount * credits_per_dollar)
+                charge_amount = int(amount * 100)  # Convert to cents
+
+            else:
+                # Fixed price plan - look up from Stripe
+                prices = stripe.Price.list(active=True, limit=100)
+                price = None
+
+                for p in prices.data:
+                    if p.id == reference_code or p.metadata.get("plan_reference") == reference_code:
+                        price = p
+                        break
+
+                if not price:
+                    raise ValueError(f"Invalid plan reference: {reference_code}")
+
+                charge_amount = price.unit_amount
+                credits_to_add = int(price.metadata.get("credits", 0))
+
+            # Get default payment method
+            default_pm = customer.invoice_settings.get("default_payment_method")
+            if not default_pm:
+                # Try to get first payment method
+                payment_methods = stripe.PaymentMethod.list(
+                    customer=customer.id,
+                    type="card",
+                    limit=1
+                )
+                if not payment_methods.data:
+                    raise ValueError("No payment method on file")
+                default_pm = payment_methods.data[0].id
+
+            # Create payment intent
+            payment_intent = stripe.PaymentIntent.create(
+                amount=charge_amount,
+                currency="usd",
+                customer=customer.id,
+                payment_method=default_pm,
+                off_session=True,
+                confirm=True,
+                description=f"Credit purchase - {credits_to_add} credits",
+                metadata={
+                    "user_id": user_id,
+                    "credits": credits_to_add,
+                    "reference_code": reference_code,
+                    "environment": self.environment
+                }
+            )
+
+            return {
+                "id": payment_intent.id,
+                "status": payment_intent.status,
+                "credits_added": credits_to_add,
+                "amount_charged": charge_amount / 100  # Convert back to dollars
+            }
+
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error processing payment: {e}")
+            raise
+
+    def customer_has_payment_method(self, stripe_customer_id: str) -> bool:
+        """
+        Check if customer has any saved payment methods.
+        """
+        try:
+            payment_methods = stripe.PaymentMethod.list(
+                customer=stripe_customer_id,
+                type="card",
+                limit=1
+            )
+            return len(payment_methods.data) > 0
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error checking payment methods: {e}")
+            return False
+
+    def list_payment_methods(self, stripe_customer_id: str) -> Dict[str, Any]:
+        """
+        List all payment methods for a customer.
+        """
+        try:
+            # Get customer to find default payment method
+            customer = stripe.Customer.retrieve(stripe_customer_id)
+            default_pm_id = customer.invoice_settings.get("default_payment_method")
+
+            # List all payment methods
+            payment_methods = stripe.PaymentMethod.list(
+                customer=stripe_customer_id,
+                type="card"
+            )
+
+            items = []
+            for pm in payment_methods.data:
+                items.append({
+                    "id": pm.id,
+                    "brand": pm.card.brand,
+                    "last4": pm.card.last4,
+                    "exp_month": pm.card.exp_month,
+                    "exp_year": pm.card.exp_year,
+                    "is_default": pm.id == default_pm_id
+                })
+
+            return {
+                "items": items,
+                "default_payment_method_id": default_pm_id
+            }
+
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error listing payment methods: {e}")
+            return {"items": [], "default_payment_method_id": None}
+
+    def _get_or_create_customer(self, user_id: str, email: Optional[str] = None) -> Any:
+        """
+        Get existing Stripe customer or create new one.
+        First checks by user_id in metadata, then by email if provided.
+        """
+        try:
+            # First try to find by user_id in metadata
+            customers = stripe.Customer.search(
+                query=f'metadata["user_id"]:"{user_id}"',
+                limit=1
+            )
+
+            if customers.data:
+                return customers.data[0]
+
+            # If email provided, try to find by email
+            if email:
+                customers = stripe.Customer.list(email=email, limit=1)
+                if customers.data:
+                    # Update metadata with user_id
+                    customer = customers.data[0]
+                    stripe.Customer.modify(
+                        customer.id,
+                        metadata={"user_id": user_id}
+                    )
+                    return customer
+
+            # Create new customer
+            return stripe.Customer.create(
+                email=email,
+                metadata={
+                    "user_id": user_id,
+                    "environment": self.environment
+                }
+            )
+
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error getting/creating customer: {e}")
+            raise
+
+    def create_subscription(self, user_id: str, email: str, price_id: str) -> Dict[str, Any]:
+        """Create a subscription for unlimited access."""
+        try:
+            # Create or retrieve customer
+            customers = stripe.Customer.list(email=email, limit=1)
+            if customers.data:
+                customer = customers.data[0]
+            else:
+                customer = stripe.Customer.create(
+                    email=email,
+                    metadata={"user_id": user_id}
+                )
+
+            # Create subscription
+            subscription = stripe.Subscription.create(
+                customer=customer.id,
+                items=[{"price": price_id}],
+                metadata={
+                    "user_id": user_id,
+                    "environment": self.environment
+                }
+            )
+
+            return {
+                "subscription_id": subscription.id,
+                "status": subscription.status,
+                "customer_id": customer.id
+            }
+
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error creating subscription: {e}")
+            raise
+
+    def pause_subscription(self, subscription_id: str) -> Dict[str, str]:
+        """Pause a subscription."""
+        try:
+            subscription = stripe.Subscription.modify(
+                subscription_id,
+                pause_collection={"behavior": "mark_uncollectible"}
+            )
+            return {"message": "Subscription paused", "status": "paused"}
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error pausing subscription: {e}")
+            raise
+
+    def resume_subscription(self, subscription_id: str) -> Dict[str, str]:
+        """Resume a paused subscription."""
+        try:
+            subscription = stripe.Subscription.modify(
+                subscription_id,
+                pause_collection=""  # Remove pause
+            )
+            return {"message": "Subscription resumed", "status": "active"}
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error resuming subscription: {e}")
+            raise
+
+    def cancel_subscription(self, subscription_id: str) -> Dict[str, str]:
+        """Cancel a subscription."""
+        try:
+            subscription = stripe.Subscription.delete(subscription_id)
+            return {"message": "Subscription cancelled", "status": "cancelled"}
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error cancelling subscription: {e}")
+            raise
+
+    def _get_mock_plans(self) -> List[Plan]:
+        """Return mock plans for development/testing."""
+        return [
+            Plan(
+                plan_reference="79541679412215",
+                plan_type="prepaid",
+                plan_name="STANDARD",
+                plan_subtitle="One-time purchase",
+                plan_amount=10.0,
+                plan_credits=5000,
+                plan_credits_text="5,000 credits",
+                percent_off=""
+            ),
+            Plan(
+                plan_reference="79541679412216",
+                plan_type="prepaid",
+                plan_name="POWER",
+                plan_subtitle="Best value",
+                plan_amount=50.0,
+                plan_credits=28500,
+                plan_credits_text="28,500 credits",
+                percent_off="12.5% OFF"
+            ),
+            Plan(
+                plan_reference="79541679412217",
+                plan_type="prepaid",
+                plan_name="ELITE",
+                plan_subtitle="Maximum savings",
+                plan_amount=100.0,
+                plan_credits=66666,
+                plan_credits_text="66,666 credits",
+                percent_off="25% OFF"
+            ),
+            Plan(
+                plan_reference="price_unlimited",
+                plan_type="postpaid",
+                plan_name="UNLIMITED",
+                plan_subtitle="Monthly subscription",
+                plan_amount=299.0,
+                plan_credits=None,
+                plan_credits_text="Unlimited",
+                percent_off=""
+            )
+        ]

ai_lls_lib/payment/webhook_processor.py

@@ -0,0 +1,163 @@
+"""Stripe webhook event processing."""
+
+import json
+import logging
+from typing import Dict, Any
+
+try:
+    import stripe
+except ImportError:
+    stripe = None
+
+from .credit_manager import CreditManager
+
+logger = logging.getLogger(__name__)
+
+
+class WebhookProcessor:
+    """Process Stripe webhook events."""
+
+    def __init__(self, webhook_secret: str, credit_manager: CreditManager):
+        """Initialize with webhook secret and credit manager."""
+        self.webhook_secret = webhook_secret
+        self.credit_manager = credit_manager
+
+    def verify_and_parse(self, payload: str, signature: str) -> Dict[str, Any]:
+        """Verify webhook signature and parse event."""
+        if not stripe:
+            raise ImportError("stripe package not installed")
+
+        try:
+            event = stripe.Webhook.construct_event(
+                payload, signature, self.webhook_secret
+            )
+            return event
+        except ValueError as e:
+            logger.error(f"Invalid webhook payload: {e}")
+            raise
+        except stripe.error.SignatureVerificationError as e:
+            logger.error(f"Invalid webhook signature: {e}")
+            raise
+
+    def process_event(self, event: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Process a verified webhook event.
+        Returns response data.
+        """
+        event_type = event.get("type")
+        event_data = event.get("data", {}).get("object", {})
+
+        logger.info(f"Processing webhook event: {event_type}")
+
+        if event_type == "checkout.session.completed":
+            return self._handle_checkout_completed(event_data)
+
+        elif event_type == "customer.subscription.created":
+            return self._handle_subscription_created(event_data)
+
+        elif event_type == "customer.subscription.updated":
+            return self._handle_subscription_updated(event_data)
+
+        elif event_type == "customer.subscription.deleted":
+            return self._handle_subscription_deleted(event_data)
+
+        elif event_type == "invoice.payment_succeeded":
+            return self._handle_invoice_paid(event_data)
+
+        elif event_type == "invoice.payment_failed":
+            return self._handle_invoice_failed(event_data)
+
+        else:
+            logger.info(f"Unhandled event type: {event_type}")
+            return {"message": f"Event {event_type} received but not processed"}
+
+    def _handle_checkout_completed(self, session: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle successful checkout session for credit purchase."""
+        metadata = session.get("metadata", {})
+        user_id = metadata.get("user_id")
+
+        if not user_id:
+            logger.error("No user_id in checkout session metadata")
+            return {"error": "Missing user_id"}
+
+        # Get line items to determine credits purchased
+        if session.get("mode") == "payment":
+            # One-time payment for credits
+            # In production, fetch line items from Stripe to get price metadata
+            # For now, extract from session metadata if available
+            credits = int(metadata.get("credits", 0))
+
+            if credits > 0:
+                new_balance = self.credit_manager.add_credits(user_id, credits)
+                logger.info(f"Added {credits} credits to user {user_id}, new balance: {new_balance}")
+                return {"credits_added": credits, "new_balance": new_balance}
+
+        return {"message": "Checkout processed"}
+
+    def _handle_subscription_created(self, subscription: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle new subscription creation."""
+        metadata = subscription.get("metadata", {})
+        user_id = metadata.get("user_id")
+        customer_id = subscription.get("customer")
+        subscription_id = subscription.get("id")
+        status = subscription.get("status")
+
+        if user_id:
+            self.credit_manager.set_subscription_state(
+                user_id=user_id,
+                status=status,
+                stripe_customer_id=customer_id,
+                stripe_subscription_id=subscription_id
+            )
+            logger.info(f"Created subscription {subscription_id} for user {user_id}")
+
+        return {"subscription_id": subscription_id, "status": status}
+
+    def _handle_subscription_updated(self, subscription: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle subscription updates (pause/resume/etc)."""
+        metadata = subscription.get("metadata", {})
+        user_id = metadata.get("user_id")
+        subscription_id = subscription.get("id")
+        status = subscription.get("status")
+
+        if user_id:
+            self.credit_manager.set_subscription_state(
+                user_id=user_id,
+                status=status,
+                stripe_subscription_id=subscription_id
+            )
+            logger.info(f"Updated subscription {subscription_id} status to {status}")
+
+        return {"subscription_id": subscription_id, "status": status}
+
+    def _handle_subscription_deleted(self, subscription: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle subscription cancellation."""
+        metadata = subscription.get("metadata", {})
+        user_id = metadata.get("user_id")
+        subscription_id = subscription.get("id")
+
+        if user_id:
+            self.credit_manager.set_subscription_state(
+                user_id=user_id,
+                status="cancelled",
+                stripe_subscription_id=subscription_id
+            )
+            logger.info(f"Cancelled subscription {subscription_id} for user {user_id}")
+
+        return {"subscription_id": subscription_id, "status": "cancelled"}
+
+    def _handle_invoice_paid(self, invoice: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle successful subscription payment."""
+        # For monthly subscriptions, could grant monthly credit allotment here
+        # For now, just log the payment
+        customer_id = invoice.get("customer")
+        amount = invoice.get("amount_paid", 0) / 100.0
+        logger.info(f"Invoice paid: ${amount} from customer {customer_id}")
+        return {"amount_paid": amount}
+
+    def _handle_invoice_failed(self, invoice: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle failed subscription payment."""
+        customer_id = invoice.get("customer")
+        logger.warning(f"Invoice payment failed for customer {customer_id}")
+        # Could pause subscription or send notification here
+        return {"status": "payment_failed"}

{ai_lls_lib-1.1.0.dist-info → ai_lls_lib-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ai-lls-lib
-Version: 1.1.0
+Version: 1.2.0
 Summary: Landline Scrubber core library - phone verification and DNC checking
 Author: LandlineScrubber Team
 Requires-Python: >=3.12,<4.0
@@ -14,6 +14,7 @@ Requires-Dist: httpx (>=0.25.0,<0.26.0)
 Requires-Dist: phonenumbers (>=8.13.0,<9.0.0)
 Requires-Dist: pydantic (>=2.5.0,<3.0.0)
 Requires-Dist: rich (>=14.0,<15.0)
+Requires-Dist: stripe (>=12.5.1,<13.0.0)
 Description-Content-Type: text/markdown
 
 # AI LLS Library

{ai_lls_lib-1.1.0.dist-info → ai_lls_lib-1.2.0.dist-info}/RECORD

@@ -1,24 +1,33 @@
-ai_lls_lib/__init__.py,sha256=d5gZDobIQ9_C7Ed5NB4RIgtoLWk_eHko_6Rh43aPPwk,584
+ai_lls_lib/__init__.py,sha256=vX28RZKgWt_4PDkQ_H69AwCCp7Jt9nHwhxt4RhKOotU,584
+ai_lls_lib/auth/__init__.py,sha256=c6zomHSB6y9Seakf84ciGsD3XgWarIty9xty6P8fxVw,194
+ai_lls_lib/auth/context_parser.py,sha256=8I0vGbtykNLWqm8ldedxXjE-E3nqsCy113JgeyuiJoM,2222
 ai_lls_lib/cli/__init__.py,sha256=m9qjZTW1jpENwXAUeuRrlP0b66BWRcqSO28MSjvOyCs,74
-ai_lls_lib/cli/__main__.py,sha256=DH9x08k6GWBSqVWspHgWTxGM7NkTBZ2OS2KrVW-XQaA,671
+ai_lls_lib/cli/__main__.py,sha256=8tUdq4GJwzIiTC1pvCsTkwmq8iNujdFTbI45_wm3d7A,716
 ai_lls_lib/cli/aws_client.py,sha256=YcCWCpTNOW9JPLxSNLRy5-F5HPKguJJk7dPNrPqhJv0,3952
 ai_lls_lib/cli/commands/__init__.py,sha256=_kROrYuR_p2i110c0OvNeArfEFQbn15zR1c3pdeZOoo,28
 ai_lls_lib/cli/commands/admin.py,sha256=bNBJi2fZBP0J40JQP6HP7NYadNmI214iII1TeLhooyE,6687
 ai_lls_lib/cli/commands/cache.py,sha256=vWt0vy4L9CEgUEWUzfdehU6u43PE8vUvHx7xxg4e5tw,5680
+ai_lls_lib/cli/commands/stripe.py,sha256=x5QtirbCPiBrjdMRVTR0aeQN2gy0_p6jcGzELObFfzg,12006
 ai_lls_lib/cli/commands/test_stack.py,sha256=rNq4mhRXX7Ixo67kSoEPWlxqgXCzM9e2PR96qTAG7pE,7378
 ai_lls_lib/cli/commands/verify.py,sha256=V5ucjmjCUxqN8_AeEJWWgrmYin8BNV3h4WbZ-iX3loU,4238
+ai_lls_lib/cli/env_loader.py,sha256=YTCB6QDyknOuedPbQsW4bezB5SgHzJMGjhpSPArHFVc,3762
 ai_lls_lib/core/__init__.py,sha256=QUaeQHIyvknkgMxIbfXRo1a5jSQpiJkB84dId5ubuEk,36
 ai_lls_lib/core/cache.py,sha256=MubgyAF3y7BBF9am39Ni98NgikZ9UBZUG-KtbE3XWX4,3711
 ai_lls_lib/core/models.py,sha256=ABRYaeMCWahQh4WdbkCxt3AO0-EvPWZwlL-JITQSnEM,2381
 ai_lls_lib/core/processor.py,sha256=6752IPDQ-Mz5i_CU7aBM0UjvV7IjyZFl35LKVPkHMpc,9974
 ai_lls_lib/core/verifier.py,sha256=6uB_jawWoIqsNYAadTKr0lSolIWygg2gK6ykf8lrul0,2716
+ai_lls_lib/payment/__init__.py,sha256=xhUWgfLnk3syXXQItswmDXdfXUyJTXTQAA0zIUuCVII,295
+ai_lls_lib/payment/credit_manager.py,sha256=TDrdW7BYjhtlg8MX_EJEnMNct1SU_6Tdb_k19_e8kpo,6343
+ai_lls_lib/payment/models.py,sha256=JjSmWKwpuFF85Jzmabj6y7UyolJlJlsh5CmOWRg21B8,3339
+ai_lls_lib/payment/stripe_manager.py,sha256=-L329stuu-6V_QKzRdkm9qnoi74SbWzST0fuf2WAJXA,17111
+ai_lls_lib/payment/webhook_processor.py,sha256=UVngeAGcou5ieRAp-49pqdWh0wsJQVwpiRoLmyl5Adc,6448
 ai_lls_lib/providers/__init__.py,sha256=AEv3ARenWDwDo5PLCoszP2fQ70RgSHkrSLSUz7xHJDk,179
 ai_lls_lib/providers/base.py,sha256=344XYOg7bxDQMWJ6Lle8U7NOHpabnCp0XYbZpeWpPAk,681
 ai_lls_lib/providers/external.py,sha256=-Hhnlm8lQWRcWr5vG0dmD3sca2rohURrx0usOR2y1MM,2623
 ai_lls_lib/providers/stub.py,sha256=847Tmw522B3HQ2j38BH1sdcZQy--RdtDcXsrIrFKNBQ,1150
 ai_lls_lib/testing/__init__.py,sha256=RUxRYBzzPCPS15Umb6bUrE6rL5BQXBQf4SJM2E3ffrg,39
 ai_lls_lib/testing/fixtures.py,sha256=_n6bbr95LnQf9Dvu1qKs2HsvHEA7AAbe59B75qxE10w,3310
-ai_lls_lib-1.1.0.dist-info/METADATA,sha256=x9A545GW7f-YQ-IMmkKeV3Lu1JMxDX6PB4VB4_Nw_Eo,7207
-ai_lls_lib-1.1.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-ai_lls_lib-1.1.0.dist-info/entry_points.txt,sha256=Pi0V_HBViEKGFbNQKatl5lhhnHHBXlxaom-5gH9gXZ0,55
-ai_lls_lib-1.1.0.dist-info/RECORD,,
+ai_lls_lib-1.2.0.dist-info/METADATA,sha256=o76nenDApQ5pITFYnlmX7IS-maEi39JgU75iUyI9udk,7248
+ai_lls_lib-1.2.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+ai_lls_lib-1.2.0.dist-info/entry_points.txt,sha256=Pi0V_HBViEKGFbNQKatl5lhhnHHBXlxaom-5gH9gXZ0,55
+ai_lls_lib-1.2.0.dist-info/RECORD,,