intentkit 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

intentkit/skills/nation/nft_check.py

@@ -0,0 +1,106 @@
+import logging
+from typing import Optional, Type
+
+import httpx
+from eth_utils import is_address
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from .base import NationBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class NftCheckInput(BaseModel):
+    nation_wallet_address: Optional[str] = Field(
+        default=None, description="Nation wallet address"
+    )
+
+
+class NftCheck(NationBaseTool):
+    name: str = "nft_check"
+    description: str = "Check user nation pass NFTs stats in nation, including usage status and linked agents.By default, it will use the user_id as the wallet address. If you want to check other wallet address, please pass the nation_wallet_address parameter."
+    args_schema: Type[BaseModel] = NftCheckInput
+
+    async def _arun(
+        self, nation_wallet_address: Optional[str] = None, config: RunnableConfig = None
+    ) -> str:
+        """Implementation of the NFT Check tool.
+
+        Args:
+            nation_wallet_address: The wallet address of the nation (optional), if not passed, then get user_id from chat as wallet address.
+            config: Configuration for the runnable.
+
+        Returns:
+            str: Formatted NFT check results based on the nation wallet address.
+        """
+
+        context = self.context_from_config(config)
+        logger.debug(f"nft_check.py: Running NFT check with context {context}")
+
+        # Use the provided nation_wallet_address or fetch it from the context
+        if not nation_wallet_address:
+            nation_wallet_address = context.user_id
+            if not nation_wallet_address:
+                raise ValueError(
+                    "Nation wallet address is not provided and not found in context"
+                )
+
+        # Validate the normalized address
+        if not is_address(nation_wallet_address):
+            raise ValueError(
+                f"Invalid Ethereum wallet address: {nation_wallet_address}"
+            )
+
+        url = f"{self.get_base_url()}/v1/users/{nation_wallet_address}"
+
+        api_key = self.get_api_key()
+
+        if not api_key:
+            raise ValueError("Backend API key not found")
+
+        headers = {"Accept": "application/json", "x-api-key": api_key}
+
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.get(url, headers=headers)
+
+                if response.status_code != 200:
+                    logger.error(
+                        f"nft_check.py: Error from API: {response.status_code} - {response.text}"
+                    )
+                    return f"Error fetching NFT data: {response.status_code} - {response.text}"
+
+                data = response.json()
+                nfts = data.get("nfts", [])
+
+                if not nfts:
+                    return f"No NFTs found for wallet address: {nation_wallet_address}"
+
+                # Format the NFT data
+                formatted_results = (
+                    f"NFTs for wallet address '{nation_wallet_address}':\n\n"
+                )
+
+                for i, nft in enumerate(nfts, 1):
+                    token_id = nft.get("token_id", "Unknown")
+                    used_by = nft.get("used_by", None)
+                    linked_agent_id = nft.get("linked_agent_id", "None")
+
+                    formatted_results += f"{i}. Token ID: {token_id}\n"
+                    if used_by:
+                        formatted_results += (
+                            f"   Status: Used by Agent ID {linked_agent_id}\n"
+                        )
+                    else:
+                        formatted_results += "   Status: Available\n"
+                    formatted_results += "\n"
+
+                return formatted_results.strip()
+
+        except httpx.TimeoutException:
+            logger.error("nft_check.py: Request timed out")
+            return "The request to the NFT API timed out. Please try again later."
+        except Exception as e:
+            logger.error(f"nft_check.py: Error fetching NFT data: {e}", exc_info=True)
+            return "An error occurred while fetching NFT data. Please try again later."

intentkit/skills/nation/schema.json

@@ -0,0 +1,58 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "Nation",
+  "description": "Check nation NFT stats",
+  "x-icon": "https://ai.service.crestal.dev/skills/nation/nation.png",
+  "x-tags": [
+    "Nation",
+    "NFTChecker"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "nft_check": {
+          "type": "string",
+          "title": "Nation NFT Usage Check",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Check User Nation NFT Usage",
+          "default": "disabled"
+        }
+      },
+      "description": "States for each Nation skill"
+    },
+    "api_key_provider": {
+      "type": "string",
+      "title": "API Key Provider",
+      "description": "Who provides the API key",
+      "enum": [
+        "platform"
+      ],
+      "x-enum-title": [
+        "Nation Hosted"
+      ],
+      "default": "platform"
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "additionalProperties": true
+}

intentkit/skills/openai/__init__.py

@@ -0,0 +1,107 @@
+"""OpenAI skills."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.openai.base import OpenAIBaseTool
+from intentkit.skills.openai.dalle_image_generation import DALLEImageGeneration
+from intentkit.skills.openai.gpt_image_generation import GPTImageGeneration
+from intentkit.skills.openai.gpt_image_to_image import GPTImageToImage
+from intentkit.skills.openai.image_to_text import ImageToText
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, OpenAIBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    image_to_text: SkillState
+    dalle_image_generation: SkillState
+    gpt_image_generation: SkillState
+    gpt_image_to_image: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for OpenAI skills."""
+
+    states: SkillStates
+    api_key: str
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[OpenAIBaseTool]:
+    """Get all OpenAI skills.
+
+    Args:
+        config: The configuration for OpenAI skills.
+        is_private: Whether to include private skills.
+        store: The skill store for persisting data.
+
+    Returns:
+        A list of OpenAI 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_openai_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_openai_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> OpenAIBaseTool:
+    """Get an OpenAI skill by name.
+
+    Args:
+        name: The name of the skill to get
+        store: The skill store for persisting data
+
+    Returns:
+        The requested OpenAI skill
+    """
+    if name == "image_to_text":
+        if name not in _cache:
+            _cache[name] = ImageToText(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "dalle_image_generation":
+        if name not in _cache:
+            _cache[name] = DALLEImageGeneration(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "gpt_image_generation":
+        if name not in _cache:
+            _cache[name] = GPTImageGeneration(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "gpt_image_to_image":
+        if name not in _cache:
+            _cache[name] = GPTImageToImage(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        logger.warning(f"Unknown OpenAI skill: {name}")
+        return None

intentkit/skills/openai/base.py

@@ -0,0 +1,32 @@
+"""Base class for OpenAI skills."""
+
+from typing import Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill, SkillContext
+
+
+class OpenAIBaseTool(IntentKitSkill):
+    """Base class for all OpenAI skills.
+
+    This class provides common functionality for all OpenAI skills.
+    """
+
+    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"
+    )
+
+    def get_api_key(self, context: SkillContext) -> str:
+        skill_config = context.config
+        if skill_config.get("api_key_provider") == "agent_owner":
+            return skill_config.get("api_key")
+        return self.skill_store.get_system_config("openai_api_key")
+
+    @property
+    def category(self) -> str:
+        return "openai"

intentkit/skills/openai/dalle_image_generation.py

@@ -0,0 +1,128 @@
+"""DALL-E image generation skill for OpenAI."""
+
+import logging
+from typing import Type
+
+import openai
+from epyxid import XID
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.openai.base import OpenAIBaseTool
+from intentkit.utils.s3 import store_image
+
+logger = logging.getLogger(__name__)
+
+
+class DALLEImageGenerationInput(BaseModel):
+    """Input for DALLEImageGeneration tool."""
+
+    prompt: str = Field(
+        description="Text prompt describing the image to generate.",
+    )
+    size: str = Field(
+        default="1024x1024",
+        description="Size of the generated image. Options: 1024x1024, 1024x1792, 1792x1024",
+    )
+    quality: str = Field(
+        default="hd",
+        description="Quality of the generated image. Options: standard, hd",
+    )
+    style: str = Field(
+        default="vivid",
+        description="Style of the generated image. Options: vivid, natural",
+    )
+
+
+class DALLEImageGeneration(OpenAIBaseTool):
+    """Tool for generating high-quality images using OpenAI's DALL-E 3 model.
+
+    This tool takes a text prompt and uses OpenAI's API to generate
+    an image based on the description using the DALL-E 3 model.
+
+    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 = "dalle_image_generation"
+    description: str = (
+        "Generate images using OpenAI's DALL-E 3 model.\n"
+        "Provide a text prompt describing the image you want to generate.\n"
+        "DALL-E 3 is a powerful image generation model capable of creating detailed, "
+        "high-quality images from text descriptions.\n"
+        "You can specify size, quality, and style parameters for more control.\n"
+    )
+    args_schema: Type[BaseModel] = DALLEImageGenerationInput
+
+    async def _arun(
+        self,
+        prompt: str,
+        size: str = "1024x1024",
+        quality: str = "hd",
+        style: str = "vivid",
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> str:
+        """Implementation of the tool to generate images using OpenAI's DALL-E 3 model.
+
+        Args:
+            prompt: Text prompt describing the image to generate.
+            size: Size of the generated image. Options: 1024x1024, 1024x1792, 1792x1024
+            quality: Quality of the generated image. Options: standard, hd
+            style: Style of the generated image. Options: vivid, natural
+            config: Configuration for the runnable.
+
+        Returns:
+            str: URL of the generated image.
+
+        Raises:
+            Exception: If the image generation fails.
+        """
+        context = self.context_from_config(config)
+
+        # Get the OpenAI API key from the skill store
+        api_key = self.get_api_key(context)
+
+        # Generate a unique job ID
+        job_id = str(XID())
+
+        try:
+            # Initialize the OpenAI client
+            client = openai.OpenAI(api_key=api_key)
+
+            # Make the API request to generate the image
+            response = client.images.generate(
+                model="dall-e-3",
+                prompt=prompt,
+                size=size,
+                quality=quality,
+                style=style,
+                n=1,
+            )
+
+            # Get the image URL from the response
+            image_url = response.data[0].url
+
+            # Strip potential double quotes from the response
+            image_url = image_url.strip('"')
+
+            # Generate a key with agent ID as prefix
+            image_key = f"{context.agent.id}/dalle/{job_id}"
+
+            # Store the image and get the CDN URL
+            stored_url = await store_image(image_url, image_key)
+
+            # Return the stored image URL
+            return stored_url
+
+        except openai.OpenAIError as e:
+            error_message = f"OpenAI API error: {str(e)}"
+            logger.error(error_message)
+            raise Exception(error_message)
+
+        except Exception as e:
+            error_message = f"Error generating image with DALL-E: {str(e)}"
+            logger.error(error_message)
+            raise Exception(error_message)

intentkit/skills/openai/gpt_image_generation.py

@@ -0,0 +1,152 @@
+"""GPT image generation skill for OpenAI."""
+
+import base64
+import logging
+from typing import Literal, Type
+
+import openai
+from epyxid import XID
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.openai.base import OpenAIBaseTool
+from intentkit.utils.s3 import store_image_bytes
+
+logger = logging.getLogger(__name__)
+
+
+class GPTImageGenerationInput(BaseModel):
+    """Input for GPTImageGeneration tool."""
+
+    prompt: str = Field(
+        description="Text prompt describing the image to generate.",
+    )
+    size: Literal["1024x1024", "1536x1024", "1024x1536", "auto"] = Field(
+        default="auto",
+        description="Size of the generated image. Options: 1024x1024, 1536x1024, 1024x1536, auto",
+    )
+    quality: Literal["high", "medium", "low", "auto"] = Field(
+        default="auto",
+        description="Quality of the generated image. Options: high, medium, low, auto",
+    )
+    background: Literal["transparent", "opaque", "auto"] = Field(
+        default="auto",
+        description="Background transparency. Options: transparent, opaque, auto",
+    )
+
+
+class GPTImageGeneration(OpenAIBaseTool):
+    """Tool for generating high-quality images using OpenAI's GPT-Image-1 model.
+
+    This tool takes a text prompt and uses OpenAI's API to generate
+    an image based on the description using the GPT-Image-1 model.
+
+    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 = "gpt_image_generation"
+    description: str = (
+        "Generate images using OpenAI's GPT-Image-1 model.\n"
+        "Provide a text prompt describing the image you want to generate.\n"
+        "GPT-Image-1 is a powerful image generation model capable of creating detailed, "
+        "high-quality images from text descriptions.\n"
+        "You can specify size, quality, and background parameters for more control.\n"
+    )
+    args_schema: Type[BaseModel] = GPTImageGenerationInput
+
+    async def _arun(
+        self,
+        prompt: str,
+        size: Literal["1024x1024", "1536x1024", "1024x1536", "auto"] = "auto",
+        quality: Literal["high", "medium", "low", "auto"] = "auto",
+        background: Literal["transparent", "opaque", "auto"] = "auto",
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> str:
+        """Implementation of the tool to generate images using OpenAI's GPT-Image-1 model.
+
+        Args:
+            prompt: Text prompt describing the image to generate.
+            size: Size of the generated image. Options: 1024x1024, 1536x1024, 1024x1536, auto
+            quality: Quality of the generated image. Options: high, medium, low, auto
+            background: Background transparency. Options: transparent, opaque, auto
+            config: Configuration for the runnable.
+
+        Returns:
+            str: URL of the generated image.
+
+        Raises:
+            Exception: If the image generation fails.
+        """
+        context = self.context_from_config(config)
+
+        # Get the OpenAI API key from the skill store
+        api_key = self.get_api_key(context)
+
+        # Generate a unique job ID
+        job_id = str(XID())
+
+        try:
+            # Initialize the OpenAI client
+            client = openai.OpenAI(api_key=api_key)
+
+            # Determine content type based on background setting
+            content_type = "image/png" if background == "transparent" else "image/jpeg"
+
+            # Make the API request to generate the image
+            response = client.images.generate(
+                model="gpt-image-1",
+                prompt=prompt,
+                size=size,
+                quality=quality,
+                background=background,
+                moderation="low",  # Using low moderation as specified
+                n=1,
+            )
+
+            # GPT-Image-1 always returns base64-encoded images
+            # Get the base64 image data from the response
+            base64_image = response.data[0].b64_json
+
+            # Log the usage information if available
+            if hasattr(response, "usage") and response.usage:
+                usage = response.usage
+                logger.info(
+                    f"GPT-Image-1 generation usage: "
+                    f"input_tokens={usage.input_tokens}, "
+                    f"output_tokens={usage.output_tokens}, "
+                    f"total_tokens={usage.total_tokens}"
+                )
+
+                # Log detailed input tokens information if available
+                if (
+                    hasattr(usage, "input_tokens_details")
+                    and usage.input_tokens_details
+                ):
+                    details = usage.input_tokens_details
+                    logger.info(f"Input tokens details: {details}")
+
+            # Decode the base64 string to bytes
+            image_bytes = base64.b64decode(base64_image)
+
+            # Generate a key with agent ID as prefix
+            image_key = f"{context.agent.id}/gpt-image/{job_id}"
+
+            # Store the image bytes and get the CDN URL
+            stored_url = await store_image_bytes(image_bytes, image_key, content_type)
+
+            # Return the stored image URL
+            return stored_url
+
+        except openai.OpenAIError as e:
+            error_message = f"OpenAI API error: {str(e)}"
+            logger.error(error_message)
+            raise Exception(error_message)
+
+        except Exception as e:
+            error_message = f"Error generating image with GPT-Image-1: {str(e)}"
+            logger.error(error_message)
+            raise Exception(error_message)