intentkit 0.6.13.dev2__py3-none-any.whl → 0.8.17__py3-none-any.whl

intentkit/skills/casino/__init__.py

@@ -0,0 +1,86 @@
+"""Casino skills for card games and dice rolling."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.casino.base import CasinoBaseTool
+from intentkit.skills.casino.deck_draw import CasinoDeckDraw
+from intentkit.skills.casino.deck_shuffle import CasinoDeckShuffle
+from intentkit.skills.casino.dice_roll import CasinoDiceRoll
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, CasinoBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    deck_shuffle: SkillState
+    deck_draw: SkillState
+    dice_roll: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for Casino skills."""
+
+    states: SkillStates
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    **_,
+) -> list[CasinoBaseTool]:
+    """Get all Casino skills.
+
+    Args:
+        config: The configuration for Casino skills.
+        is_private: Whether to include private skills.
+
+    Returns:
+        A list of Casino skills.
+    """
+    available_skills = []
+
+    # Include skills based on their state
+    for skill_name, state in config["states"].items():
+        if state == "disabled":
+            continue
+        elif state == "public" or (state == "private" and is_private):
+            available_skills.append(skill_name)
+
+    # Get each skill using the cached getter
+    result = []
+    for name in available_skills:
+        skill = get_casino_skill(name)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_casino_skill(
+    name: str,
+) -> CasinoBaseTool:
+    """Get a Casino skill by name.
+
+    Args:
+        name: The name of the skill to get
+
+    Returns:
+        The requested Casino skill
+    """
+    if name == "deck_shuffle":
+        if name not in _cache:
+            _cache[name] = CasinoDeckShuffle()
+        return _cache[name]
+    elif name == "deck_draw":
+        if name not in _cache:
+            _cache[name] = CasinoDeckDraw()
+        return _cache[name]
+    elif name == "dice_roll":
+        if name not in _cache:
+            _cache[name] = CasinoDiceRoll()
+        return _cache[name]
+    else:
+        raise ValueError(f"Unknown Casino skill: {name}")

intentkit/skills/casino/base.py

@@ -0,0 +1,17 @@
+"""Base class for Casino tools."""
+
+from pydantic import BaseModel, Field
+
+from intentkit.skills.base import IntentKitSkill
+
+
+class CasinoBaseTool(IntentKitSkill):
+    """Base class for Casino tools."""
+
+    name: str = Field(description="The name of the tool")
+    description: str = Field(description="A description of what the tool does")
+    args_schema: type[BaseModel]
+
+    @property
+    def category(self) -> str:
+        return "casino"

intentkit/skills/casino/deck_draw.py

@@ -0,0 +1,127 @@
+"""Card drawing skill using Deck of Cards API."""
+
+import logging
+
+try:
+    import httpx
+except ImportError:
+    raise ImportError(
+        "httpx is required for Casino skills. Install it with: pip install httpx"
+    )
+from pydantic import BaseModel, Field
+
+from intentkit.skills.casino.base import CasinoBaseTool
+from intentkit.skills.casino.utils import (
+    CURRENT_DECK_KEY,
+    DECK_STORAGE_KEY,
+    ENDPOINTS,
+    RATE_LIMITS,
+    format_card_info,
+    validate_card_count,
+)
+
+NAME = "casino_deck_draw"
+PROMPT = (
+    "Draw cards from the current deck. If no deck exists, a new one will be created. "
+    "Returns detailed card information including images."
+)
+
+logger = logging.getLogger(__name__)
+
+
+class CasinoDeckDrawInput(BaseModel):
+    """Input for CasinoDeckDraw tool."""
+
+    count: int = Field(default=1, description="Number of cards to draw (1-10)")
+
+
+class CasinoDeckDraw(CasinoBaseTool):
+    """Tool for drawing cards from a deck.
+
+    This tool uses the Deck of Cards API to draw cards from the current deck.
+
+    Attributes:
+        name: The name of the tool.
+        description: A description of what the tool does.
+        args_schema: The schema for the tool's input arguments.
+    """
+
+    name: str = NAME
+    description: str = PROMPT
+    args_schema: type[BaseModel] = CasinoDeckDrawInput
+
+    async def _arun(self, count: int = 1, **kwargs) -> dict:
+        try:
+            context = self.get_context()
+
+            # Apply rate limit using built-in user_rate_limit method
+            rate_config = RATE_LIMITS["deck_draw"]
+            await self.user_rate_limit(
+                rate_config["max_requests"],
+                rate_config["interval"],
+                "deck_draw",
+            )
+
+            # Validate count
+            count = validate_card_count(count)
+
+            # Get current deck info
+            deck_info = await self.get_agent_skill_data_raw(
+                DECK_STORAGE_KEY, CURRENT_DECK_KEY
+            )
+
+            deck_id = "new"  # Default to new deck
+            if deck_info and deck_info.get("deck_id"):
+                deck_id = deck_info["deck_id"]
+
+            # Build API URL
+            url = ENDPOINTS["deck_draw"].format(deck_id=deck_id)
+            params = {"count": count}
+
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url, params=params)
+
+                if response.status_code == 200:
+                    data = response.json()
+
+                    if data.get("success"):
+                        # Update deck info
+                        if deck_id == "new":
+                            deck_info = {
+                                "deck_id": data["deck_id"],
+                                "deck_count": 1,
+                                "jokers_enabled": False,
+                                "remaining": data["remaining"],
+                                "shuffled": True,
+                            }
+                        else:
+                            deck_info["remaining"] = data["remaining"]
+
+                        await self.save_agent_skill_data_raw(
+                            DECK_STORAGE_KEY,
+                            CURRENT_DECK_KEY,
+                            deck_info,
+                        )
+
+                        # Format card information with images
+                        cards = [
+                            format_card_info(card) for card in data.get("cards", [])
+                        ]
+
+                        return {
+                            "success": True,
+                            "cards_drawn": cards,
+                            "remaining_cards": data["remaining"],
+                            "deck_id": data["deck_id"],
+                            "message": f"Drew {len(cards)} card{'s' if len(cards) > 1 else ''} "
+                            f"({data['remaining']} remaining)",
+                        }
+                    else:
+                        return {"success": False, "error": "Failed to draw cards"}
+                else:
+                    logger.error(f"Deck API error: {response.status_code}")
+                    return {"success": False, "error": "Failed to draw cards"}
+
+        except Exception as e:
+            logger.error(f"Error drawing cards: {str(e)}")
+            raise type(e)(f"[agent:{context.agent_id}]: {e}") from e

intentkit/skills/casino/deck_shuffle.py

@@ -0,0 +1,118 @@
+"""Deck shuffling skill using Deck of Cards API."""
+
+import logging
+
+try:
+    import httpx
+except ImportError:
+    raise ImportError(
+        "httpx is required for Casino skills. Install it with: pip install httpx"
+    )
+from pydantic import BaseModel, Field
+
+from intentkit.skills.casino.base import CasinoBaseTool
+from intentkit.skills.casino.utils import (
+    CURRENT_DECK_KEY,
+    DECK_STORAGE_KEY,
+    ENDPOINTS,
+    RATE_LIMITS,
+    validate_deck_count,
+)
+
+NAME = "casino_deck_shuffle"
+PROMPT = (
+    "Create and shuffle a new deck of cards. You can specify the number of decks "
+    "to use (default is 1) and optionally include jokers."
+)
+
+logger = logging.getLogger(__name__)
+
+
+class CasinoDeckShuffleInput(BaseModel):
+    """Input for CasinoDeckShuffle tool."""
+
+    deck_count: int = Field(
+        default=1, description="Number of decks to use (1-6, default 1)"
+    )
+    jokers_enabled: bool = Field(
+        default=False, description="Whether to include jokers in the deck"
+    )
+
+
+class CasinoDeckShuffle(CasinoBaseTool):
+    """Tool for creating and shuffling card decks.
+
+    This tool uses the Deck of Cards API to create new shuffled decks.
+
+    Attributes:
+        name: The name of the tool.
+        description: A description of what the tool does.
+        args_schema: The schema for the tool's input arguments.
+    """
+
+    name: str = NAME
+    description: str = PROMPT
+    args_schema: type[BaseModel] = CasinoDeckShuffleInput
+
+    async def _arun(
+        self, deck_count: int = 1, jokers_enabled: bool = False, **kwargs
+    ) -> dict:
+        try:
+            context = self.get_context()
+
+            # Apply rate limit using built-in user_rate_limit method
+            rate_config = RATE_LIMITS["deck_shuffle"]
+            await self.user_rate_limit(
+                rate_config["max_requests"],
+                rate_config["interval"],
+                "deck_shuffle",
+            )
+
+            # Validate deck count
+            deck_count = validate_deck_count(deck_count)
+
+            # Build API URL and parameters
+            url = ENDPOINTS["deck_new_shuffle"]
+            params = {"deck_count": deck_count}
+
+            if jokers_enabled:
+                params["jokers_enabled"] = "true"
+
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url, params=params)
+
+                if response.status_code == 200:
+                    data = response.json()
+
+                    # Store deck info for the agent
+                    deck_info = {
+                        "deck_id": data["deck_id"],
+                        "deck_count": deck_count,
+                        "jokers_enabled": jokers_enabled,
+                        "remaining": data["remaining"],
+                        "shuffled": data["shuffled"],
+                    }
+
+                    await self.save_agent_skill_data_raw(
+                        DECK_STORAGE_KEY,
+                        CURRENT_DECK_KEY,
+                        deck_info,
+                    )
+
+                    return {
+                        "success": True,
+                        "deck_id": data["deck_id"],
+                        "deck_count": deck_count,
+                        "jokers_enabled": jokers_enabled,
+                        "remaining_cards": data["remaining"],
+                        "message": f"Created and shuffled {'a new deck' if deck_count == 1 else f'{deck_count} decks'} "
+                        f"with {data['remaining']} cards"
+                        + (" (including jokers)" if jokers_enabled else ""),
+                    }
+                else:
+                    logger.error(f"Deck API error: {response.status_code}")
+                    return {"success": False, "error": "Failed to create deck"}
+
+        except Exception as e:
+            logger.error(f"Error shuffling deck: {str(e)}")
+            raise type(e)(f"[agent:{context.agent_id}]: {e}") from e

intentkit/skills/casino/dice_roll.py

@@ -0,0 +1,100 @@
+"""Quantum dice rolling skill using QRandom API."""
+
+import logging
+
+try:
+    import httpx
+except ImportError:
+    raise ImportError(
+        "httpx is required for Casino skills. Install it with: pip install httpx"
+    )
+from pydantic import BaseModel, Field
+
+from intentkit.skills.casino.base import CasinoBaseTool
+from intentkit.skills.casino.utils import (
+    ENDPOINTS,
+    RATE_LIMITS,
+    get_dice_visual,
+    validate_dice_count,
+)
+
+NAME = "casino_dice_roll"
+PROMPT = (
+    "Roll quantum random dice using true quantum randomness. "
+    "Can roll multiple 6-sided dice at once for games."
+)
+
+logger = logging.getLogger(__name__)
+
+
+class CasinoDiceRollInput(BaseModel):
+    """Input for CasinoDiceRoll tool."""
+
+    dice_count: int = Field(default=1, description="Number of dice to roll (1-10)")
+
+
+class CasinoDiceRoll(CasinoBaseTool):
+    """Tool for rolling quantum random dice.
+
+    This tool uses the QRandom API to generate truly random dice rolls
+    using quantum randomness.
+
+    Attributes:
+        name: The name of the tool.
+        description: A description of what the tool does.
+        args_schema: The schema for the tool's input arguments.
+    """
+
+    name: str = NAME
+    description: str = PROMPT
+    args_schema: type[BaseModel] = CasinoDiceRollInput
+
+    async def _arun(self, dice_count: int = 1, **kwargs) -> dict:
+        try:
+            context = self.get_context()
+
+            # Apply rate limit using built-in user_rate_limit method
+            rate_config = RATE_LIMITS["dice_roll"]
+            await self.user_rate_limit(
+                rate_config["max_requests"],
+                rate_config["interval"],
+                "dice_roll",
+            )
+
+            # Validate dice count
+            dice_count = validate_dice_count(dice_count)
+
+            # Build API URL
+            url = ENDPOINTS["dice_roll"]
+            params = {"n": dice_count}
+
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url, params=params)
+
+                if response.status_code == 200:
+                    data = response.json()
+
+                    dice_results = data.get("dice", [])
+                    total = sum(dice_results)
+
+                    # Generate dice emoji representation
+                    dice_visual = get_dice_visual(dice_results)
+
+                    return {
+                        "success": True,
+                        "dice_results": dice_results,
+                        "dice_visual": dice_visual,
+                        "total": total,
+                        "dice_count": len(dice_results),
+                        "quantum_signature": data.get("signature", ""),
+                        "quantum_id": data.get("id", ""),
+                        "message": f"Rolled {len(dice_results)} dice: {' '.join(dice_visual)} "
+                        f"(Total: {total})",
+                    }
+                else:
+                    logger.error(f"QRandom API error: {response.status_code}")
+                    return {"success": False, "error": "Failed to roll dice"}
+
+        except Exception as e:
+            logger.error(f"Error rolling dice: {str(e)}")
+            raise type(e)(f"[agent:{context.agent_id}]: {e}") from e

intentkit/skills/casino/schema.json

@@ -0,0 +1,77 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "Casino",
+  "description": "Casino gaming skills including card decks and quantum dice rolling for interactive games with users",
+  "x-icon": "https://ai.service.crestal.dev/skills/casino/casino.png",
+  "x-tags": [
+    "Entertainment"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "deck_shuffle": {
+          "type": "string",
+          "title": "Shuffle Card Deck",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Create and shuffle new card decks with customizable options",
+          "default": "disabled"
+        },
+        "deck_draw": {
+          "type": "string",
+          "title": "Draw Cards",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Draw cards from the current deck with detailed card information and images",
+          "default": "disabled"
+        },
+        "dice_roll": {
+          "type": "string",
+          "title": "Roll Quantum Dice",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Roll dice using quantum random number generation for true randomness",
+          "default": "disabled"
+        }
+      },
+      "description": "States for each Casino skill"
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "additionalProperties": true
+}

intentkit/skills/casino/utils.py

@@ -0,0 +1,107 @@
+"""
+Casino Skills Utilities
+
+Common constants, URLs, and helper functions for Casino skills.
+"""
+
+# API URLs
+DECK_OF_CARDS_API_BASE = "https://www.deckofcardsapi.com/api/deck"
+QRANDOM_API_BASE = "https://qrandom.io/api/random"
+
+# API Endpoints
+ENDPOINTS = {
+    "deck_new_shuffle": f"{DECK_OF_CARDS_API_BASE}/new/shuffle/",
+    "deck_draw": f"{DECK_OF_CARDS_API_BASE}/{{deck_id}}/draw/",
+    "dice_roll": f"{QRANDOM_API_BASE}/dice",
+}
+
+# Rate Limits (requests per minute)
+RATE_LIMITS = {
+    "deck_shuffle": {"max_requests": 20, "interval": 60},
+    "deck_draw": {"max_requests": 30, "interval": 60},
+    "dice_roll": {"max_requests": 15, "interval": 60},
+}
+
+# Storage Keys
+DECK_STORAGE_KEY = "casino_deck"
+CURRENT_DECK_KEY = "current_deck"
+
+# Dice visual representation
+DICE_EMOJI = ["⚀", "⚁", "⚂", "⚃", "⚄", "⚅"]
+
+# Card back image URL for display
+CARD_BACK_IMAGE = "https://www.deckofcardsapi.com/static/img/back.png"
+
+# Validation limits
+MAX_DECK_COUNT = 6
+MIN_DECK_COUNT = 1
+MAX_CARDS_DRAW = 10
+MIN_CARDS_DRAW = 1
+MAX_DICE_COUNT = 10
+MIN_DICE_COUNT = 1
+
+
+def get_dice_visual(dice_results: list[int]) -> list[str]:
+    """Convert dice numbers to emoji representation.
+
+    Args:
+        dice_results: List of dice roll results (1-6)
+
+    Returns:
+        List of dice emoji strings
+    """
+    return [DICE_EMOJI[result - 1] for result in dice_results if 1 <= result <= 6]
+
+
+def validate_deck_count(count: int) -> int:
+    """Validate and normalize deck count.
+
+    Args:
+        count: Requested deck count
+
+    Returns:
+        Normalized deck count within valid range
+    """
+    return max(MIN_DECK_COUNT, min(MAX_DECK_COUNT, count))
+
+
+def validate_card_count(count: int) -> int:
+    """Validate and normalize card draw count.
+
+    Args:
+        count: Requested card count
+
+    Returns:
+        Normalized card count within valid range
+    """
+    return max(MIN_CARDS_DRAW, min(MAX_CARDS_DRAW, count))
+
+
+def validate_dice_count(count: int) -> int:
+    """Validate and normalize dice count.
+
+    Args:
+        count: Requested dice count
+
+    Returns:
+        Normalized dice count within valid range
+    """
+    return max(MIN_DICE_COUNT, min(MAX_DICE_COUNT, count))
+
+
+def format_card_info(card: dict) -> dict:
+    """Format card information for consistent output.
+
+    Args:
+        card: Raw card data from Deck of Cards API
+
+    Returns:
+        Formatted card information
+    """
+    return {
+        "value": card["value"],
+        "suit": card["suit"],
+        "code": card["code"],
+        "image": card["image"],
+        "svg_image": card["images"]["svg"],
+    }