intentkit 0.6.17.dev2__tar.gz → 0.6.18__tar.gz

{intentkit-0.6.17.dev2 → intentkit-0.6.18}/.gitignore

@@ -168,9 +168,7 @@ cython_debug/
 # IDE
 .idea
 .vscode
-.trae
 .cursor
-.windsurfrules
 
 # web3
 wallet_data.txt

{intentkit-0.6.17.dev2 → intentkit-0.6.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.6.17.dev2
+Version: 0.6.18
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestal-network/intentkit
 Project-URL: Repository, https://github.com/crestal-network/intentkit

{intentkit-0.6.17.dev2 → intentkit-0.6.18}/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.6.17-dev2"
+__version__ = "0.6.18"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

{intentkit-0.6.17.dev2 → intentkit-0.6.18}/models/agent_schema.json

@@ -547,6 +547,10 @@
         "lifi": {
           "title": "LiFi",
           "$ref": "../skills/lifi/schema.json"
+        },
+        "casino": {
+          "title": "Casino",
+          "$ref": "../skills/casino/schema.json"
         }
       }
     },

{intentkit-0.6.17.dev2 → intentkit-0.6.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intentkit"
-version = "0.6.17-dev2"
+version = "0.6.18"
 description = "Intent-based AI Agent Platform - Core Package"
 authors = [{ name = "hyacinthus", email = "hyacinthus@gmail.com" }]
 requires-python = ">=3.12"

{intentkit-0.6.17.dev2 → intentkit-0.6.18}/skills/base.py

@@ -2,7 +2,6 @@ import asyncio
 import logging
 from typing import Any, Callable, Dict, Literal, NotRequired, Optional, TypedDict, Union
 
-from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import BaseTool
 from langchain_core.tools.base import ToolException
 from langgraph.runtime import get_runtime
@@ -180,22 +179,9 @@ class IntentKitSkill(BaseTool):
             "Use _arun instead, IntentKit only supports synchronous skill calls"
         )
 
-    def context_from_config(self, runner_config: RunnableConfig) -> SkillContext:
-        if "configurable" not in runner_config:
-            raise ValueError("configurable not in runner_config")
-        configurable = runner_config["configurable"]
-        if not configurable:
-            raise ValueError("configurable in runnable config is empty")
-        return SkillContext(
-            skill_category=self.category,
-            agent_id=configurable.get("agent_id"),
-            user_id=configurable.get("user_id"),
-            app_id=configurable.get("app_id"),
-            chat_id=configurable.get("chat_id"),
-            entrypoint=configurable.get("entrypoint"),
-            is_private=configurable.get("is_private"),
-        )
-
-    def get_context(self) -> AgentContext:
+    @staticmethod
+    def get_context() -> AgentContext:
         runtime = get_runtime(AgentContext)
+        if runtime.context is None or not isinstance(runtime.context, AgentContext):
+            raise ValueError("No AgentContext found")
         return runtime.context

intentkit-0.6.18/skills/casino/README.md

@@ -0,0 +1,254 @@
+# Casino Skills for IntentKit
+
+The Casino skills provide comprehensive gambling and gaming capabilities for AI agents, enabling interactive card games, dice games, and casino-style entertainment.
+
+## 🎯 Overview
+
+This skill set includes three main functions:
+- **Deck Shuffling**: Create and shuffle card decks with customizable options
+- **Card Drawing**: Draw cards with visual PNG/SVG images 
+- **Quantum Dice Rolling**: True random dice using quantum number generation
+
+## 🛠️ Available Skills
+
+### 1. `casino_deck_shuffle`
+Creates and shuffles new card decks with options for multiple decks and jokers.
+
+**Parameters:**
+- `deck_count` (int): Number of decks (1-6, default: 1)
+- `jokers_enabled` (bool): Include jokers (default: false)
+
+### 2. `casino_deck_draw` 
+Draws cards from the current deck with detailed information and images.
+
+**Parameters:**
+- `count` (int): Number of cards to draw (1-10, default: 1)
+
+### 3. `casino_dice_roll`
+Rolls quantum random dice with visual representation.
+
+**Parameters:**
+- `dice_count` (int): Number of dice to roll (1-10, default: 1)
+
+## 🎮 Game Examples
+
+### 🃏 Blackjack (21)
+
+**Setup:**
+```
+Agent: I'll set up a Blackjack game for you! Let me shuffle a fresh deck.
+[Calls casino_deck_shuffle with deck_count=1]
+```
+
+**Dealing Cards:**
+```
+Agent: Dealing your cards...
+[Calls casino_deck_draw with count=2 for player]
+[Calls casino_deck_draw with count=1 for dealer, 1 face down]
+
+Result: You have: King♠️ (image) + 7♥️ (image) = 17
+Dealer shows: Ace♣️ (image) + [hidden card]
+```
+
+**Player Actions:**
+```
+User: "Hit me"
+Agent: [Calls casino_deck_draw with count=1]
+Result: You drew 3♦️ (image). Total: 20
+
+User: "Stand"
+Agent: Revealing dealer's hidden card...
+[Calls casino_deck_draw for dealer's hidden card and additional cards as needed]
+```
+
+### 🎲 Craps
+
+**Come Out Roll:**
+```
+Agent: Welcome to the Craps table! Place your bets and let's roll!
+[Calls casino_dice_roll with dice_count=2]
+
+Result: 🎲 Rolled: ⚂ ⚃ (3 + 4 = 7) - WINNER! 
+The shooter made their point on the come out roll!
+```
+
+**Point Phase:**
+```
+Agent: Point is 6. Rolling again...
+[Calls casino_dice_roll with dice_count=2]
+
+Result: 🎲 Rolled: ⚁ ⚄ (2 + 5 = 7) - Seven out! 
+New shooter coming up.
+```
+
+### 🃏 Texas Hold'em Poker
+
+**Pre-flop:**
+```
+Agent: Dealing pocket cards...
+[Calls casino_deck_shuffle with deck_count=1]
+[Calls casino_deck_draw with count=2 for each player]
+
+Your cards: A♠️ (image) K♠️ (image) - Ace-King suited!
+```
+
+**The Flop:**
+```
+Agent: Dealing the flop...
+[Calls casino_deck_draw with count=3]
+
+Flop: A♦️ (image) K♣️ (image) 7♠️ (image)
+You have two pair - Aces and Kings!
+```
+
+**Turn and River:**
+```
+Agent: Turn card...
+[Calls casino_deck_draw with count=1]
+Turn: Q♠️ (image)
+
+River card...
+[Calls casino_deck_draw with count=1] 
+River: J♠️ (image)
+
+Final board: A♦️ K♣️ 7♠️ Q♠️ J♠️
+You have a straight! A-K-Q-J-10
+```
+
+### 🎯 Yahtzee
+
+**First Roll:**
+```
+Agent: Rolling all 5 dice for Yahtzee!
+[Calls casino_dice_roll with dice_count=5]
+
+Result: ⚀ ⚃ ⚃ ⚄ ⚅ (1, 4, 4, 5, 6)
+Which dice would you like to keep?
+```
+
+**Rerolls:**
+```
+User: "Keep the two 4s"
+Agent: Rerolling 3 dice...
+[Calls casino_dice_roll with dice_count=3]
+
+Result: ⚃ ⚃ ⚃ (4, 4, 4) - Combined with your kept dice: ⚃ ⚃ ⚃ ⚃ ⚃
+YAHTZEE! Five of a kind - 4s! 🎉
+```
+
+### 🎲 Liar's Dice
+
+**Round Start:**
+```
+Agent: Everyone roll your dice under the cup!
+[Each player calls casino_dice_roll with dice_count=5]
+
+Your dice (hidden): ⚁ ⚁ ⚂ ⚄ ⚅ (2, 2, 3, 5, 6)
+```
+
+**Bidding:**
+```
+User: "I bid three 2s"
+Agent: Player 2 bids four 3s...
+Player 3 calls "Liar!" on Player 2.
+
+Revealing all dice...
+[Shows all dice rolled by each player]
+Total 3s on table: 2 dice
+Player 2 bid four 3s but there were only 2. Player 2 loses a die!
+```
+
+### 🃏 War (Card Game)
+
+**Battle:**
+```
+Agent: Time for War! Each player draws one card.
+[Calls casino_deck_draw with count=1 for each player]
+
+You: Q♦️ (image) - Queen of Diamonds
+Opponent: 8♣️ (image) - Eight of Clubs
+
+Queen beats 8 - You win this round!
+```
+
+**War Declaration:**
+```
+Agent: Both players drew Kings! It's WAR! 
+[Calls casino_deck_draw with count=4 for each player - 3 face down, 1 face up]
+
+Your war card: A♠️ (image) - Ace of Spades
+Opponent's war card: 10♥️ (image) - Ten of Hearts
+
+Ace beats 10 - You win the entire war pile!
+```
+
+## 🎨 Visual Features
+
+### Card Images
+Each card comes with both PNG and SVG images:
+```json
+{
+  "value": "ACE",
+  "suit": "SPADES", 
+  "code": "AS",
+  "image": "https://deckofcardsapi.com/static/img/AS.png",
+  "svg_image": "https://deckofcardsapi.com/static/img/AS.svg"
+}
+```
+
+### Dice Visualization
+Dice results include emoji representation:
+- ⚀ (1) ⚁ (2) ⚂ (3) ⚃ (4) ⚄ (5) ⚅ (6)
+
+### Game State Persistence
+- Deck state maintained between draws
+- Remaining cards tracked automatically  
+- Each agent has independent game sessions
+
+## 🛡️ Built-in Features
+
+### Rate Limiting
+- **Deck Shuffle**: 20 requests/minute
+- **Card Draw**: 30 requests/minute  
+- **Dice Roll**: 15 requests/minute
+
+### Error Handling
+- Automatic deck creation if none exists
+- Graceful API failure handling
+- Input validation and sanitization
+
+### Quantum Randomness
+Dice rolling uses true quantum random number generation from QRandom.io for authentic unpredictability, complete with quantum signatures for verification.
+
+## 🚀 Getting Started
+
+1. Enable Casino skills in your agent configuration
+2. Set skill states (public/private/disabled) for each function
+3. Start gaming! The agent will automatically manage decks and game state
+
+## 🎪 Advanced Gaming Scenarios
+
+### Multi-Table Casino
+```
+Agent: Welcome to the Nation Casino! I'm managing 3 tables:
+- Table 1: Blackjack (6-deck shoe)
+- Table 2: Poker Tournament 
+- Table 3: Craps with side bets
+
+Which table interests you?
+```
+
+### Tournament Mode
+```
+Agent: Poker Tournament - Round 1 of 3
+Blinds: 50/100 chips
+[Manages multiple hands, tracks chip counts, advances rounds]
+```
+
+### Live Dealer Experience  
+```
+Agent: 🎭 Good evening! I'm your live dealer tonight.
+[Maintains casino atmosphere, explains rules, manages multiple players]
+```
+
+The Casino skills transform your AI agent into a comprehensive gaming companion capable of hosting authentic casino experiences with visual cards, quantum dice, and persistent game management! 🎰🎲🃏

intentkit-0.6.18/skills/casino/__init__.py

@@ -0,0 +1,97 @@
+"""Casino skills for card games and dice rolling."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+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,
+    store: SkillStoreABC,
+    **_,
+) -> list[CasinoBaseTool]:
+    """Get all Casino skills.
+
+    Args:
+        config: The configuration for Casino skills.
+        is_private: Whether to include private skills.
+        store: The skill store for persisting data.
+
+    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, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_casino_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> CasinoBaseTool:
+    """Get a Casino skill by name.
+
+    Args:
+        name: The name of the skill to get
+        store: The skill store for persisting data
+
+    Returns:
+        The requested Casino skill
+    """
+    if name == "deck_shuffle":
+        if name not in _cache:
+            _cache[name] = CasinoDeckShuffle(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "deck_draw":
+        if name not in _cache:
+            _cache[name] = CasinoDeckDraw(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "dice_roll":
+        if name not in _cache:
+            _cache[name] = CasinoDiceRoll(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        raise ValueError(f"Unknown Casino skill: {name}")

intentkit-0.6.18/skills/casino/base.py

@@ -0,0 +1,23 @@
+"""Base class for Casino tools."""
+
+from typing import Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+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]
+    skill_store: SkillStoreABC = Field(
+        description="The skill store for persisting data"
+    )
+
+    @property
+    def category(self) -> str:
+        return "casino"

intentkit-0.6.18/skills/casino/deck_draw.py

@@ -0,0 +1,130 @@
+"""Card drawing skill using Deck of Cards API."""
+
+import logging
+from typing import Type
+
+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(
+                context.user_id or context.agent_id,
+                rate_config["max_requests"],
+                rate_config["interval"] // 60,  # Convert to minutes
+                "deck_draw",
+            )
+
+            # Validate count
+            count = validate_card_count(count)
+
+            # Get current deck info
+            deck_info = await self.skill_store.get_agent_skill_data(
+                context.agent_id, 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.skill_store.save_agent_skill_data(
+                            context.agent_id,
+                            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