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

intentkit/skills/openai/gpt_image_to_image.py

@@ -0,0 +1,186 @@
+"""GPT image-to-image generation skill for OpenAI."""
+
+import base64
+import logging
+from io import BytesIO
+from typing import Literal, Type
+
+import httpx
+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 GPTImageToImageInput(BaseModel):
+    """Input for GPTImageToImage tool."""
+
+    image_url: str = Field(
+        description="URL of the source image to edit.",
+    )
+    prompt: str = Field(
+        description="Text prompt describing the desired edits to the image.",
+    )
+    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",
+    )
+
+
+class GPTImageToImage(OpenAIBaseTool):
+    """Tool for editing images using OpenAI's GPT-Image-1 model.
+
+    This tool takes a source image URL and a text prompt, then uses OpenAI's API to
+    generate an edited version of the image based on the description.
+
+    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_to_image"
+    description: str = (
+        "Edit images using OpenAI's GPT-Image-1 model.\n"
+        "Provide a source image URL and a text prompt describing the desired edits.\n"
+        "GPT-Image-1 is a powerful image editing model capable of transforming images "
+        "based on text descriptions.\n"
+        "You can specify size and quality parameters for more control.\n"
+    )
+    args_schema: Type[BaseModel] = GPTImageToImageInput
+
+    async def _arun(
+        self,
+        image_url: str,
+        prompt: str,
+        size: Literal["1024x1024", "1536x1024", "1024x1536", "auto"] = "auto",
+        quality: Literal["high", "medium", "low", "auto"] = "auto",
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> str:
+        """Implementation of the tool to edit images using OpenAI's GPT-Image-1 model.
+
+        Args:
+            image_url: URL of the source image to edit.
+            prompt: Text prompt describing the desired edits to the image.
+            size: Size of the generated image. Options: 1024x1024, 1536x1024, 1024x1536, auto
+            quality: Quality of the generated image. Options: high, medium, low, auto
+            config: Configuration for the runnable.
+
+        Returns:
+            str: URL of the edited image.
+
+        Raises:
+            Exception: If the image editing 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:
+            # Download the image from the URL asynchronously
+            async with httpx.AsyncClient() as client:
+                response = await client.get(image_url, follow_redirects=True)
+                response.raise_for_status()
+                image_data = response.content
+
+            # Initialize the OpenAI client
+            client = openai.OpenAI(api_key=api_key)
+
+            # Import required modules for file handling
+            import os
+            import tempfile
+
+            from PIL import Image
+
+            # Create a temporary file with .png extension
+            with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp_file:
+                temp_path = temp_file.name
+
+                # Open the image, convert to RGB if needed, and save as PNG
+                img = Image.open(BytesIO(image_data))
+                if img.mode != "RGB":
+                    img = img.convert("RGB")
+                img.save(temp_path, format="PNG")
+
+            # Open the temporary file in binary read mode
+            # This provides both .read() method and .name attribute that OpenAI SDK needs
+            image_file = open(temp_path, "rb")
+
+            # Make the API request to edit the image
+            try:
+                response = client.images.edit(
+                    model="gpt-image-1",
+                    image=image_file,  # Use the file object with .read() method and .name attribute
+                    prompt=prompt,
+                    size=size,
+                    quality=quality,
+                    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 edit 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-edit/{job_id}"
+
+                # Store the image bytes and get the CDN URL
+                stored_url = await store_image_bytes(image_bytes, image_key)
+            finally:
+                # Close and remove the temporary file
+                image_file.close()
+                if os.path.exists(temp_path):
+                    os.unlink(temp_path)
+
+            # Return the stored image URL
+            return stored_url
+
+        except httpx.HTTPError as e:
+            error_message = f"Failed to download image from URL {image_url}: {str(e)}"
+            logger.error(error_message)
+            raise Exception(error_message)
+
+        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 editing image with GPT-Image-1: {str(e)}"
+            logger.error(error_message)
+            raise Exception(error_message)

intentkit/skills/openai/image_to_text.py

@@ -0,0 +1,126 @@
+import io
+import logging
+from typing import Type
+
+import aiohttp
+import openai
+from langchain_core.runnables import RunnableConfig
+from PIL import Image
+from pydantic import BaseModel, Field
+
+from intentkit.skills.openai.base import OpenAIBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class ImageToTextInput(BaseModel):
+    """Input for ImageToText tool."""
+
+    image: str = Field(
+        description="URL of the image to convert to text.",
+    )
+
+
+class ImageToTextOutput(BaseModel):
+    """Output for ImageToText tool."""
+
+    description: str = Field(description="Detailed text description of the image.")
+    width: int = Field(description="Width of the processed image.")
+    height: int = Field(description="Height of the processed image.")
+
+
+class ImageToText(OpenAIBaseTool):
+    """Tool for converting images to text using OpenAI's GPT-4o model.
+
+    This tool takes an image URL and uses OpenAI's vision capabilities
+    to generate a detailed text description of the image content.
+
+    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 = "image_to_text"
+    description: str = (
+        "Convert an image to detailed text description.\n"
+        "Provide a URL to the image to analyze and get a comprehensive textual description.\n"
+        "Optimized for DALL-E generated images and preserves as many details as possible."
+    )
+    args_schema: Type[BaseModel] = ImageToTextInput
+
+    async def _arun(
+        self, image: str, config: RunnableConfig, **kwargs
+    ) -> ImageToTextOutput:
+        """Implementation of the tool to convert images to text.
+
+        Args:
+            image (str): URL of the image to convert to text.
+
+        Returns:
+            ImageToTextOutput: Object containing the text description and image dimensions.
+        """
+        context = self.context_from_config(config)
+        logger.debug(f"context: {context}")
+
+        # Get the OpenAI client from the skill store
+        api_key = self.get_api_key(context)
+        client = openai.AsyncOpenAI(api_key=api_key)
+
+        try:
+            # Download the image from the URL
+            async with aiohttp.ClientSession() as session:
+                async with session.get(image) as response:
+                    if response.status != 200:
+                        raise Exception(
+                            f"Failed to download image from URL: {response.status}"
+                        )
+
+                    # Get image data
+                    image_data = await response.read()
+                    img = Image.open(io.BytesIO(image_data))
+
+                    # Get original dimensions
+                    orig_width, orig_height = img.size
+
+                    # Calculate new dimensions with longest side as 1024 (for reference only)
+                    max_size = 1024
+                    if orig_width >= orig_height:
+                        scaled_width = max_size
+                        scaled_height = int(orig_height * (max_size / orig_width))
+                    else:
+                        scaled_height = max_size
+                        scaled_width = int(orig_width * (max_size / orig_height))
+
+            # Use OpenAI API to analyze the image (using original image)
+            response = await client.chat.completions.create(
+                model="gpt-4o",
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You are an expert image analyzer. Describe the image in great detail, capturing all visual elements, colors, composition, subjects, and context. If there are people in the picture, be sure to clearly describe the person's skin color, hair color, expression, direction, etc. For DALL-E generated images, pay special attention to artistic style, lighting effects, and fantastical elements. Preserve as many details as possible in your description.",
+                    },
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": "Describe this image in detail:"},
+                            {
+                                "type": "image_url",
+                                "image_url": {"url": image, "detail": "high"},
+                            },
+                        ],
+                    },
+                ],
+                max_tokens=1000,
+            )
+
+            # Return the text description and scaled image dimensions
+            return ImageToTextOutput(
+                description=response.choices[0].message.content,
+                width=scaled_width,
+                height=scaled_height,
+            )
+
+        except Exception as e:
+            logger.error(f"Error converting image to text: {e}")
+            raise Exception(f"Error converting image to text: {str(e)}")

intentkit/skills/openai/schema.json

@@ -0,0 +1,139 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "OpenAI",
+  "description": "Skills for interacting with OpenAI services, including image generation, image-to-text conversion, and other AI capabilities",
+  "x-icon": "https://ai.service.crestal.dev/skills/openai/openai.png",
+  "x-tags": [
+    "AI",
+    "Image Generation",
+    "Image Analysis"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": true
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "image_to_text": {
+          "type": "string",
+          "title": "Image to Text",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Convert images to detailed text descriptions using OpenAI's GPT-4o model",
+          "default": "private"
+        },
+        "dalle_image_generation": {
+          "type": "string",
+          "title": "Image Generation by DALL-E",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Generate images using OpenAI's DALL-E model based on text prompts",
+          "default": "disabled"
+        },
+        "gpt_image_generation": {
+          "type": "string",
+          "title": "Image Generation by GPT",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Generate images using OpenAI's GPT-Image-1 model based on text prompts",
+          "default": "private"
+        },
+        "gpt_image_to_image": {
+          "type": "string",
+          "title": "Image Editing by GPT",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Edit images using OpenAI's GPT-Image-1 model based on text prompts",
+          "default": "private"
+        }
+      },
+      "description": "States for each OpenAI skill (disabled, public, or private)"
+    },
+    "api_key_provider": {
+      "type": "string",
+      "title": "API Key Provider",
+      "description": "Provider of the API key",
+      "enum": [
+        "platform",
+        "agent_owner"
+      ],
+      "x-enum-title": [
+        "Nation Hosted",
+        "Owner Provided"
+      ],
+      "default": "platform"
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "if": {
+    "properties": {
+      "api_key_provider": {
+        "const": "agent_owner"
+      }
+    }
+  },
+  "then": {
+    "properties": {
+      "api_key": {
+        "type": "string",
+        "title": "API Key",
+        "x-link": "[Get your API key](https://platform.openai.com/)",
+        "x-sensitive": true,
+        "description": "OpenAI API key for authentication"
+      }
+    },
+    "if": {
+      "properties": {
+        "enabled": {
+          "const": true
+        }
+      }
+    },
+    "then": {
+      "required": [
+        "api_key"
+      ]
+    }
+  },
+  "additionalProperties": true
+}

intentkit/skills/portfolio/README.md

@@ -0,0 +1,55 @@
+# Blockchain Portfolio Analysis Skills
+
+A set of skills for analyzing blockchain wallets and portfolios through the Moralis API, allowing agents to retrieve wallet data, token balances, and investment performance across various blockchain networks.
+
+## Available Skills
+
+| Skill | Description | Endpoint | Example Prompts |
+|-------|-------------|----------|----------------|
+| `wallet_history` | Gets transaction history including sends, receives, token transfers | `GET /wallets/{address}/history` | "Show me all transactions for wallet 0x123..." <br> "What are the recent transactions for this ETH address?" |
+| `token_balances` | Gets token balances and USD value with spam filtering options | `GET /wallets/{address}/tokens` | "What tokens does wallet 0x123 hold?" <br> "Show me token balances with USD values for this address" |
+| `wallet_approvals` | Lists active ERC20 token approvals to identify spend permissions | `GET /wallets/{address}/approvals` | "Check what contracts have approval to spend from wallet 0x123" <br> "Has this wallet approved any token spending?" |
+| `wallet_swaps` | Lists all swap-related transactions (buy/sell) for trade analysis | `GET /wallets/{address}/swaps` | "Show me all token swaps for wallet 0x123" <br> "What trading activity has this address performed?" |
+| `wallet_net_worth` | Calculates total wallet value in USD across multiple chains | `GET /wallets/{address}/net-worth` | "What's the total value of wallet 0x123?" <br> "Calculate the net worth of this address across all chains" |
+| `wallet_profitability_summary` | Provides overview of wallet profitability metrics | `GET /wallets/{address}/profitability/summary` | "Is wallet 0x123 profitable overall?" <br> "Give me a summary of trading performance for this address" |
+| `wallet_profitability` | Delivers detailed profitability by token with buy/sell prices | `GET /wallets/{address}/profitability` | "Show detailed profit/loss for each token in wallet 0x123" <br> "What's the cost basis of tokens in this wallet?" |
+| `wallet_stats` | Provides statistics about NFTs, collections, and transactions | `GET /wallets/{address}/stats` | "How many NFTs does wallet 0x123 have?" <br> "Give me stats about this wallet's activity" |
+| `wallet_defi_positions` | Get DeFi positions for a wallet | `GET /wallets/{address}/defi/positions` | "What DeFi positions does my wallet have?" <br> "Show my liquidity positions." |
+| `wallet_nfts` | Get NFTs owned by a wallet address | `GET /{address}/nft` | "What NFTs does wallet 0x123 own?" <br> "Show me all the NFTs in my wallet." |
+
+All endpoints use the base URL defined in `constants.py`: `https://deep-index.moralis.io/api/v2.2`
+
+## Migration Note
+
+If you're currently using the Moralis module, simply update your configuration by changing `moralis:` to `portfolio:`. All functionality remains identical.
+
+## Authentication
+
+All API requests include the Moralis API key in the header:
+```
+X-API-Key: YOUR_MORALIS_API_KEY
+```
+
+## Supported Chains
+
+These skills support various EVM-compatible chains:
+- Ethereum (eth)
+- Polygon (polygon)
+- Binance Smart Chain (bsc)
+- Avalanche (avalanche)
+- Arbitrum (arbitrum)
+- Optimism (optimism)
+- Base (base)
+
+## Key Parameters
+
+Most endpoints support these common parameters:
+- `chain`: The chain to query (default: eth)
+- `limit`: Number of results per page
+- `cursor`: Pagination cursor for subsequent requests
+
+## Getting a Moralis API Key
+
+1. Create an account at [Moralis.io](https://moralis.io/)
+2. Navigate to the API Keys section in your dashboard
+3. Create a new key with appropriate permissions

intentkit/skills/portfolio/__init__.py

@@ -0,0 +1,151 @@
+"""Portfolio skills for blockchain wallet analysis."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.portfolio.base import PortfolioBaseTool
+from intentkit.skills.portfolio.token_balances import TokenBalances
+from intentkit.skills.portfolio.wallet_approvals import WalletApprovals
+from intentkit.skills.portfolio.wallet_defi_positions import WalletDefiPositions
+from intentkit.skills.portfolio.wallet_history import WalletHistory
+from intentkit.skills.portfolio.wallet_net_worth import WalletNetWorth
+from intentkit.skills.portfolio.wallet_nfts import WalletNFTs
+from intentkit.skills.portfolio.wallet_profitability import WalletProfitability
+from intentkit.skills.portfolio.wallet_profitability_summary import (
+    WalletProfitabilitySummary,
+)
+from intentkit.skills.portfolio.wallet_stats import WalletStats
+from intentkit.skills.portfolio.wallet_swaps import WalletSwaps
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, PortfolioBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    """State configurations for Portfolio skills."""
+
+    wallet_history: SkillState
+    token_balances: SkillState
+    wallet_approvals: SkillState
+    wallet_swaps: SkillState
+    wallet_net_worth: SkillState
+    wallet_profitability_summary: SkillState
+    wallet_profitability: SkillState
+    wallet_stats: SkillState
+    wallet_defi_positions: SkillState
+    wallet_nfts: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for Portfolio blockchain analysis skills."""
+
+    states: SkillStates
+    api_key: str
+    api_key_provider: str
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[PortfolioBaseTool]:
+    """Get all Portfolio blockchain analysis skills.
+
+    Args:
+        config: The configuration for Portfolio skills.
+        is_private: Whether to include private skills.
+        store: The skill store for persisting data.
+
+    Returns:
+        A list of Portfolio blockchain analysis 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_portfolio_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_portfolio_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> PortfolioBaseTool:
+    """Get a portfolio skill by name."""
+    if name == "wallet_history":
+        if name not in _cache:
+            _cache[name] = WalletHistory(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "token_balances":
+        if name not in _cache:
+            _cache[name] = TokenBalances(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "wallet_approvals":
+        if name not in _cache:
+            _cache[name] = WalletApprovals(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "wallet_swaps":
+        if name not in _cache:
+            _cache[name] = WalletSwaps(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "wallet_net_worth":
+        if name not in _cache:
+            _cache[name] = WalletNetWorth(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "wallet_profitability_summary":
+        if name not in _cache:
+            _cache[name] = WalletProfitabilitySummary(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "wallet_profitability":
+        if name not in _cache:
+            _cache[name] = WalletProfitability(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "wallet_stats":
+        if name not in _cache:
+            _cache[name] = WalletStats(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "wallet_defi_positions":
+        if name not in _cache:
+            _cache[name] = WalletDefiPositions(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "wallet_nfts":
+        if name not in _cache:
+            _cache[name] = WalletNFTs(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        raise ValueError(f"Unknown portfolio skill: {name}")