Session 1: The Agentic Commerce Revolution

"""
Shopify AI Agent - Complete Solution
Production-ready implementation with error handling,
cost tracking, and conversation context.
"""

import os
import json
import logging
import requests
from typing import List, Dict

import anthropic

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Configuration
class Config:
    ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
    SHOPIFY_STORE_URL = os.getenv("SHOPIFY_STORE_URL")
    SHOPIFY_ACCESS_TOKEN = os.getenv("SHOPIFY_ACCESS_TOKEN")
    MODEL = "claude-3-5-sonnet-20241022"
    MAX_TOKENS = 4096

    # Cost tracking
    COST_PER_INPUT_TOKEN = 0.003 / 1000
    COST_PER_OUTPUT_TOKEN = 0.015 / 1000

# Shopify API Client with error handling
class ShopifyClient:
    def __init__(self, store_url, access_token):
        self.store_url = store_url.rstrip('/')
        self.access_token = access_token
        self.base_url = f"https://{store_url}/admin/api/2024-01"
        self.headers = {
            "X-Shopify-Access-Token": access_token,
            "Content-Type": "application/json"
        }

    def _make_request(self, method, endpoint, retries=3, **kwargs):
        """Make API request with retry logic"""
        url = f"{self.base_url}{endpoint}"

        for attempt in range(retries):
            try:
                response = requests.request(
                    method, url, headers=self.headers,
                    timeout=10, **kwargs
                )
                response.raise_for_status()
                return response.json()
            except requests.exceptions.HTTPError as e:
                if e.response.status_code == 429:
                    wait_time = 2 ** attempt
                    logger.warning(f"Rate limited. Waiting {wait_time}s")
                    import time
                    time.sleep(wait_time)
                    continue
                logger.error(f"HTTP error: {e}")
                return {"error": str(e)}
            except Exception as e:
                logger.error(f"Request error: {e}")
                return {"error": str(e)}

        return {"error": "Max retries exceeded"}

    def search_products(self, query: str, limit: int = 5):
        """Search products with intelligent filtering"""
        logger.info(f"Searching: '{query}', limit={limit}")

        response = self._make_request(
            "GET", "/products.json",
            params={"limit": 250}
        )

        if "error" in response:
            return []

        products = response.get("products", [])
        query_lower = query.lower()
        filtered = []

        for product in products:
            title = product.get("title", "").lower()
            if query_lower in title:
                filtered.append(self._format_product(product))
                if len(filtered) >= limit:
                    break

        logger.info(f"Found {len(filtered)} products")
        return filtered

    def _format_product(self, product):
        """Format product data"""
        variants = product.get("variants", [])
        first_variant = variants[0] if variants else {}
        images = product.get("images", [])

        return {
            "id": product.get("id"),
            "title": product.get("title"),
            "price": first_variant.get("price", "0.00"),
            "description": product.get("body_html", "")[:200],
            "image_url": images[0].get("src") if images else "",
            "in_stock": first_variant.get("inventory_quantity", 0) > 0
        }

# Cost Tracker
class CostTracker:
    def __init__(self):
        self.total_cost = 0.0
        self.conversations = 0

    def add_usage(self, input_tokens, output_tokens):
        cost = (
            input_tokens * Config.COST_PER_INPUT_TOKEN +
            output_tokens * Config.COST_PER_OUTPUT_TOKEN
        )
        self.total_cost += cost
        self.conversations += 1
        logger.info(f"Cost: ${cost:.4f}")

# Main Agent with production features
class ShopifyAgent:
    def __init__(self, config):
        self.config = config
        self.anthropic_client = anthropic.Anthropic(
            api_key=config.ANTHROPIC_API_KEY
        )
        self.shopify_client = ShopifyClient(
            config.SHOPIFY_STORE_URL,
            config.SHOPIFY_ACCESS_TOKEN
        )
        self.cost_tracker = CostTracker()
        self.tools = self._create_tools()
        self.tool_functions = self._create_tool_functions()

    def _create_tools(self):
        return [{
            "name": "search_products",
            "description": "Search Shopify products by keywords",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "limit": {"type": "integer", "default": 5}
                },
                "required": ["query"]
            }
        }]

    def _create_tool_functions(self):
        def search_products(query: str, limit: int = 5):
            products = self.shopify_client.search_products(query, limit)
            return json.dumps({
                "status": "success",
                "count": len(products),
                "products": products
            })

        return {"search_products": search_products}

    def chat(self, user_message: str, history=None):
        """Chat with tool calling loop"""
        if history is None:
            history = []

        history.append({"role": "user", "content": user_message})

        # Tool calling loop
        for iteration in range(10):
            response = self.anthropic_client.messages.create(
                model=self.config.MODEL,
                max_tokens=self.config.MAX_TOKENS,
                tools=self.tools,
                messages=history
            )

            # Track costs
            self.cost_tracker.add_usage(
                response.usage.input_tokens,
                response.usage.output_tokens
            )

            # Check if done
            if response.stop_reason == "end_turn":
                text = [b.text for b in response.content if hasattr(b, 'text')]
                return "\n".join(text)

            # Handle tool calls
            elif response.stop_reason == "tool_use":
                tool_results = []
                for block in response.content:
                    if block.type == "tool_use":
                        tool_name = block.name
                        tool_input = block.input
                        result = self.tool_functions[tool_name](**tool_input)
                        tool_results.append({
                            "type": "tool_result",
                            "tool_use_id": block.id,
                            "content": result
                        })

                history.append({"role": "assistant", "content": response.content})
                history.append({"role": "user", "content": tool_results})
                continue

        return "Max iterations reached"

# Demo
if __name__ == "__main__":
    agent = ShopifyAgent(Config)
    print("Agent ready!")

    queries = [
        "Show me wireless headphones under $100",
        "I'm looking for a gift for a tech enthusiast"
    ]

    for query in queries:
        print(f"\nUser: {query}")
        response = agent.chat(query)
        print(f"Agent: {response}")