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

intentkit/skills/openai/dalle_image_generation.py

@@ -1,7 +1,6 @@
 """DALL-E image generation skill for OpenAI."""
 
 import logging
-from typing import Type
 
 import openai
 from epyxid import XID
@@ -53,7 +52,7 @@ class DALLEImageGeneration(OpenAIBaseTool):
         "high-quality images from text descriptions.\n"
         "You can specify size, quality, and style parameters for more control.\n"
     )
-    args_schema: Type[BaseModel] = DALLEImageGenerationInput
+    args_schema: type[BaseModel] = DALLEImageGenerationInput
 
     async def _arun(
         self,
@@ -71,7 +70,6 @@ class DALLEImageGeneration(OpenAIBaseTool):
             quality: Quality of the generated image. Options: standard, hd
             style: Style of the generated image. Options: vivid, natural
 
-
         Returns:
             str: URL of the generated image.
 
@@ -79,12 +77,9 @@ class DALLEImageGeneration(OpenAIBaseTool):
             Exception: If the image generation fails.
         """
         context = self.get_context()
-        skill_config = context.agent.skill_config(self.category)
 
-        # Get the OpenAI API key from the skill store
-        api_key = skill_config.get("api_key") or self.skill_store.get_system_config(
-            "openai_api_key"
-        )
+        # Get the OpenAI API key from configuration or agent settings
+        api_key = self.get_api_key()
 
         # Generate a unique job ID
         job_id = str(XID())

intentkit/skills/openai/gpt_avatar_generator.py

@@ -0,0 +1,102 @@
+"""GPT avatar generator skill for OpenAI."""
+
+import base64
+import logging
+
+import openai
+from epyxid import XID
+from pydantic import BaseModel, Field
+
+from intentkit.skills.openai.base import OpenAIBaseTool
+from intentkit.utils.s3 import store_image_bytes
+
+logger = logging.getLogger(__name__)
+
+AVATAR_PROMPT_PREFIX = (
+    "Create a single, centered portrait that works perfectly as a profile avatar. "
+    "Use flattering, even lighting, a simple soft-focus background, and a composition from shoulders up. "
+    "Avoid text, logos, watermarks, and distracting elements so the result feels polished and personable."
+)
+
+
+class GPTAvatarGeneratorInput(BaseModel):
+    """Input schema for the GPT avatar generator skill."""
+
+    prompt: str = Field(
+        description="Description of the avatar or profile image to generate.",
+    )
+
+
+class GPTAvatarGenerator(OpenAIBaseTool):
+    """Tool for generating avatar-friendly images using OpenAI's GPT-Image-1-Mini model."""
+
+    name: str = "gpt_avatar_generator"
+    description: str = (
+        "Generate avatar-ready profile images using OpenAI's GPT-Image-1-Mini model."
+    )
+    args_schema = GPTAvatarGeneratorInput
+
+    async def _arun(self, prompt: str, **kwargs) -> str:
+        """Generate avatar-friendly images using OpenAI's GPT-Image-1-Mini model."""
+        context = self.get_context()
+        api_key = self.get_api_key()
+        job_id = str(XID())
+
+        composed_prompt = (
+            f"{AVATAR_PROMPT_PREFIX}\n{prompt.strip()}"
+            if prompt
+            else AVATAR_PROMPT_PREFIX
+        )
+
+        try:
+            client = openai.OpenAI(api_key=api_key)
+
+            response = client.images.generate(
+                model="gpt-image-1-mini",
+                prompt=composed_prompt,
+                size="1024x1024",
+                quality="medium",
+                background="opaque",
+                moderation="low",
+                n=1,
+            )
+
+            base64_image = response.data[0].b64_json
+
+            if hasattr(response, "usage") and response.usage:
+                usage = response.usage
+                logger.info(
+                    "GPT-Image-1-Mini avatar generation usage: "
+                    f"input_tokens={usage.input_tokens}, "
+                    f"output_tokens={usage.output_tokens}, "
+                    f"total_tokens={usage.total_tokens}"
+                )
+
+                if (
+                    hasattr(usage, "input_tokens_details")
+                    and usage.input_tokens_details
+                ):
+                    details = usage.input_tokens_details
+                    logger.info(f"Input tokens details: {details}")
+
+            image_bytes = base64.b64decode(base64_image)
+
+            image_key = f"{context.agent_id}/gpt-avatar/{job_id}"
+
+            stored_url = await store_image_bytes(
+                image_bytes,
+                image_key,
+                "image/jpeg",
+            )
+
+            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 avatar with GPT-Image-1-Mini: {str(e)}"
+            logger.error(error_message)
+            raise Exception(error_message)

intentkit/skills/openai/gpt_image_generation.py

@@ -2,7 +2,7 @@
 
 import base64
 import logging
-from typing import Literal, Type
+from typing import Literal
 
 import openai
 from epyxid import XID
@@ -54,7 +54,7 @@ class GPTImageGeneration(OpenAIBaseTool):
         "high-quality images from text descriptions.\n"
         "You can specify size, quality, and background parameters for more control.\n"
     )
-    args_schema: Type[BaseModel] = GPTImageGenerationInput
+    args_schema: type[BaseModel] = GPTImageGenerationInput
 
     async def _arun(
         self,
@@ -72,7 +72,6 @@ class GPTImageGeneration(OpenAIBaseTool):
             quality: Quality of the generated image. Options: high, medium, low, auto
             background: Background transparency. Options: transparent, opaque, auto
 
-
         Returns:
             str: URL of the generated image.
 
@@ -80,12 +79,9 @@ class GPTImageGeneration(OpenAIBaseTool):
             Exception: If the image generation fails.
         """
         context = self.get_context()
-        skill_config = context.agent.skill_config(self.category)
 
-        # Get the OpenAI API key from the skill store
-        api_key = skill_config.get("api_key") or self.skill_store.get_system_config(
-            "openai_api_key"
-        )
+        # Get the OpenAI API key from configuration or agent settings
+        api_key = self.get_api_key()
 
         # Generate a unique job ID
         job_id = str(XID())

intentkit/skills/openai/gpt_image_mini_generator.py

@@ -0,0 +1,91 @@
+"""GPT image mini generator skill for OpenAI."""
+
+import base64
+import logging
+from typing import Literal
+
+import openai
+from epyxid import XID
+
+from intentkit.skills.openai.base import OpenAIBaseTool
+from intentkit.skills.openai.gpt_image_generation import GPTImageGenerationInput
+from intentkit.utils.s3 import store_image_bytes
+
+logger = logging.getLogger(__name__)
+
+
+class GPTImageMiniGenerator(OpenAIBaseTool):
+    """Tool for generating images using OpenAI's GPT-Image-1-Mini model."""
+
+    name: str = "gpt_image_mini_generator"
+    description: str = (
+        "Generate images using OpenAI's GPT-Image-1-Mini model.\n"
+        "Provide a text prompt describing the image you want to generate.\n"
+        "GPT-Image-1-Mini delivers high-quality images with faster performance at a lower cost.\n"
+        "You can specify size, quality, and background parameters for more control.\n"
+    )
+    args_schema = 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",
+        **kwargs,
+    ) -> str:
+        """Generate images using OpenAI's GPT-Image-1-Mini model."""
+        context = self.get_context()
+        api_key = self.get_api_key()
+        job_id = str(XID())
+
+        try:
+            client = openai.OpenAI(api_key=api_key)
+
+            content_type = "image/png" if background == "transparent" else "image/jpeg"
+
+            response = client.images.generate(
+                model="gpt-image-1-mini",
+                prompt=prompt,
+                size=size,
+                quality=quality,
+                background=background,
+                moderation="low",
+                n=1,
+            )
+
+            base64_image = response.data[0].b64_json
+
+            if hasattr(response, "usage") and response.usage:
+                usage = response.usage
+                logger.info(
+                    "GPT-Image-1-Mini generation usage: "
+                    f"input_tokens={usage.input_tokens}, "
+                    f"output_tokens={usage.output_tokens}, "
+                    f"total_tokens={usage.total_tokens}"
+                )
+
+                if (
+                    hasattr(usage, "input_tokens_details")
+                    and usage.input_tokens_details
+                ):
+                    details = usage.input_tokens_details
+                    logger.info(f"Input tokens details: {details}")
+
+            image_bytes = base64.b64decode(base64_image)
+
+            image_key = f"{context.agent_id}/gpt-image-mini/{job_id}"
+
+            stored_url = await store_image_bytes(image_bytes, image_key, content_type)
+
+            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-Mini: {str(e)}"
+            logger.error(error_message)
+            raise Exception(error_message)

intentkit/skills/openai/gpt_image_to_image.py

@@ -3,7 +3,7 @@
 import base64
 import logging
 from io import BytesIO
-from typing import Literal, Type
+from typing import Literal
 
 import httpx
 import openai
@@ -55,7 +55,7 @@ class GPTImageToImage(OpenAIBaseTool):
         "based on text descriptions.\n"
         "You can specify size and quality parameters for more control.\n"
     )
-    args_schema: Type[BaseModel] = GPTImageToImageInput
+    args_schema: type[BaseModel] = GPTImageToImageInput
 
     async def _arun(
         self,
@@ -73,7 +73,6 @@ class GPTImageToImage(OpenAIBaseTool):
             size: Size of the generated image. Options: 1024x1024, 1536x1024, 1024x1536, auto
             quality: Quality of the generated image. Options: high, medium, low, auto
 
-
         Returns:
             str: URL of the edited image.
 
@@ -81,12 +80,9 @@ class GPTImageToImage(OpenAIBaseTool):
             Exception: If the image editing fails.
         """
         context = self.get_context()
-        skill_config = context.agent.skill_config(self.category)
 
-        # Get the OpenAI API key from the skill store
-        api_key = skill_config.get("api_key") or self.skill_store.get_system_config(
-            "openai_api_key"
-        )
+        # Get the OpenAI API key from configuration or agent settings
+        api_key = self.get_api_key()
 
         # Generate a unique job ID
         job_id = str(XID())

intentkit/skills/openai/image_to_text.py

@@ -1,6 +1,5 @@
 import io
 import logging
-from typing import Type
 
 import aiohttp
 import openai
@@ -46,7 +45,7 @@ class ImageToText(OpenAIBaseTool):
         "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
+    args_schema: type[BaseModel] = ImageToTextInput
 
     async def _arun(self, image: str, **kwargs) -> ImageToTextOutput:
         """Implementation of the tool to convert images to text.
@@ -58,13 +57,10 @@ class ImageToText(OpenAIBaseTool):
             ImageToTextOutput: Object containing the text description and image dimensions.
         """
         context = self.get_context()
-        skill_config = context.agent.skill_config(self.category)
         logger.debug(f"context: {context}")
 
-        # Get the OpenAI client from the skill store
-        api_key = skill_config.get("api_key") or self.skill_store.get_system_config(
-            "openai_api_key"
-        )
+        # Get the OpenAI client from configuration or agent settings
+        api_key = self.get_api_key()
         client = openai.AsyncOpenAI(api_key=api_key)
 
         try:

intentkit/skills/openai/schema.json

@@ -66,6 +66,38 @@
           "description": "Generate images using OpenAI's GPT-Image-1 model based on text prompts",
           "default": "private"
         },
+        "gpt_image_mini_generator": {
+          "type": "string",
+          "title": "Image Generation by GPT Mini",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Generate images using OpenAI's GPT-Image-1-Mini model based on text prompts",
+          "default": "private"
+        },
+        "gpt_avatar_generator": {
+          "type": "string",
+          "title": "Avatar Generation by GPT Mini",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Generate avatar-ready profile images using OpenAI's GPT-Image-1-Mini model",
+          "default": "private"
+        },
         "gpt_image_to_image": {
           "type": "string",
           "title": "Image Editing by GPT",

intentkit/skills/portfolio/__init__.py

@@ -3,7 +3,6 @@
 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
@@ -51,7 +50,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     **_,
 ) -> list[PortfolioBaseTool]:
     """Get all Portfolio blockchain analysis skills.
@@ -59,7 +57,6 @@ async def get_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.
@@ -76,7 +73,7 @@ async def get_skills(
     # Get each skill using the cached getter
     result = []
     for name in available_skills:
-        skill = get_portfolio_skill(name, store)
+        skill = get_portfolio_skill(name)
         if skill:
             result.append(skill)
     return result
@@ -84,68 +81,47 @@ async def get_skills(
 
 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,
-            )
+            _cache[name] = WalletHistory()
         return _cache[name]
     elif name == "token_balances":
         if name not in _cache:
-            _cache[name] = TokenBalances(
-                skill_store=store,
-            )
+            _cache[name] = TokenBalances()
         return _cache[name]
     elif name == "wallet_approvals":
         if name not in _cache:
-            _cache[name] = WalletApprovals(
-                skill_store=store,
-            )
+            _cache[name] = WalletApprovals()
         return _cache[name]
     elif name == "wallet_swaps":
         if name not in _cache:
-            _cache[name] = WalletSwaps(
-                skill_store=store,
-            )
+            _cache[name] = WalletSwaps()
         return _cache[name]
     elif name == "wallet_net_worth":
         if name not in _cache:
-            _cache[name] = WalletNetWorth(
-                skill_store=store,
-            )
+            _cache[name] = WalletNetWorth()
         return _cache[name]
     elif name == "wallet_profitability_summary":
         if name not in _cache:
-            _cache[name] = WalletProfitabilitySummary(
-                skill_store=store,
-            )
+            _cache[name] = WalletProfitabilitySummary()
         return _cache[name]
     elif name == "wallet_profitability":
         if name not in _cache:
-            _cache[name] = WalletProfitability(
-                skill_store=store,
-            )
+            _cache[name] = WalletProfitability()
         return _cache[name]
     elif name == "wallet_stats":
         if name not in _cache:
-            _cache[name] = WalletStats(
-                skill_store=store,
-            )
+            _cache[name] = WalletStats()
         return _cache[name]
     elif name == "wallet_defi_positions":
         if name not in _cache:
-            _cache[name] = WalletDefiPositions(
-                skill_store=store,
-            )
+            _cache[name] = WalletDefiPositions()
         return _cache[name]
     elif name == "wallet_nfts":
         if name not in _cache:
-            _cache[name] = WalletNFTs(
-                skill_store=store,
-            )
+            _cache[name] = WalletNFTs()
         return _cache[name]
     else:
         raise ValueError(f"Unknown portfolio skill: {name}")

intentkit/skills/portfolio/base.py

@@ -3,12 +3,13 @@
 import asyncio
 import logging
 from abc import ABC
-from typing import Any, Dict, Type
+from typing import Any
 
 import aiohttp
+from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
 
-from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.config.config import config
 from intentkit.skills.base import IntentKitSkill
 from intentkit.skills.portfolio.constants import MORALIS_API_BASE_URL
 
@@ -20,23 +21,26 @@ class PortfolioBaseTool(IntentKitSkill, ABC):
 
     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"
-    )
+    args_schema: type[BaseModel]
 
     def get_api_key(self) -> str:
         context = self.get_context()
         skill_config = context.agent.skill_config(self.category)
         if skill_config.get("api_key_provider") == "agent_owner":
-            return skill_config.get("api_key")
-        return self.skill_store.get_system_config("moralis_api_key")
+            api_key = skill_config.get("api_key")
+        else:
+            api_key = config.moralis_api_key
+
+        if not api_key:
+            raise ToolException("Moralis API key is not configured.")
+
+        return api_key
 
     @property
     def category(self) -> str:
         return "portfolio"
 
-    def _prepare_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
+    def _prepare_params(self, params: dict[str, Any]) -> dict[str, Any]:
         """Convert boolean values to lowercase strings for API compatibility.
 
         Args:
@@ -61,9 +65,9 @@ class PortfolioBaseTool(IntentKitSkill, ABC):
         method: str,
         endpoint: str,
         api_key: str,
-        params: Dict[str, Any] = None,
-        data: Dict[str, Any] = None,
-    ) -> Dict[str, Any]:
+        params: dict[str, Any] = None,
+        data: dict[str, Any] = None,
+    ) -> dict[str, Any]:
         """Make a request to the Moralis API.
 
         Args:
@@ -95,13 +99,23 @@ class PortfolioBaseTool(IntentKitSkill, ABC):
             ) as response:
                 if response.status >= 400:
                     error_text = await response.text()
-                    logger.error(f"portfolio/base.py: API error: {error_text}")
-                    return {
-                        "error": f"API error: {response.status}",
-                        "details": error_text,
-                    }
-
-                return await response.json()
+                    logger.error(
+                        "portfolio/base.py: API error %s for %s", response.status, url
+                    )
+                    raise ToolException(
+                        f"Moralis API error: {response.status} - {error_text}"
+                    )
+
+                try:
+                    return await response.json()
+                except aiohttp.ContentTypeError as exc:
+                    await response.text()
+                    logger.error(
+                        "portfolio/base.py: Failed to decode JSON response from %s", url
+                    )
+                    raise ToolException(
+                        "Moralis API returned invalid JSON payload."
+                    ) from exc
 
     def _run(self, *args: Any, **kwargs: Any) -> Any:
         """Execute the tool synchronously by running the async version in a loop."""

intentkit/skills/portfolio/token_balances.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -20,39 +20,39 @@ class TokenBalancesInput(BaseModel):
         description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
         default=DEFAULT_CHAIN,
     )
-    to_block: Optional[int] = Field(
+    to_block: int | None = Field(
         description="The block number up to which the balances will be checked.",
         default=None,
     )
-    token_addresses: Optional[List[str]] = Field(
+    token_addresses: list[str] | None = Field(
         description="The specific token addresses to get balances for.",
         default=None,
     )
-    exclude_spam: Optional[bool] = Field(
+    exclude_spam: bool | None = Field(
         description="Exclude spam tokens from the result.",
         default=True,
     )
-    exclude_unverified_contracts: Optional[bool] = Field(
+    exclude_unverified_contracts: bool | None = Field(
         description="Exclude unverified contracts from the result.",
         default=True,
     )
-    cursor: Optional[str] = Field(
+    cursor: str | None = Field(
         description="The cursor for pagination.",
         default=None,
     )
-    limit: Optional[int] = Field(
+    limit: int | None = Field(
         description="The number of results per page.",
         default=DEFAULT_LIMIT,
     )
-    exclude_native: Optional[bool] = Field(
+    exclude_native: bool | None = Field(
         description="Exclude native balance from the result.",
         default=None,
     )
-    max_token_inactivity: Optional[int] = Field(
+    max_token_inactivity: int | None = Field(
         description="Exclude tokens inactive for more than the given amount of days.",
         default=None,
     )
-    min_pair_side_liquidity_usd: Optional[float] = Field(
+    min_pair_side_liquidity_usd: float | None = Field(
         description="Exclude tokens with liquidity less than the specified amount in USD.",
         default=None,
     )
@@ -70,23 +70,23 @@ class TokenBalances(PortfolioBaseTool):
         "Get token balances for a specific wallet address and their token prices in USD. "
         "Includes options to exclude spam and unverified contracts."
     )
-    args_schema: Type[BaseModel] = TokenBalancesInput
+    args_schema: type[BaseModel] = TokenBalancesInput
 
     async def _arun(
         self,
         address: str,
         chain: str = DEFAULT_CHAIN,
-        to_block: Optional[int] = None,
-        token_addresses: Optional[List[str]] = None,
-        exclude_spam: Optional[bool] = True,
-        exclude_unverified_contracts: Optional[bool] = True,
-        cursor: Optional[str] = None,
-        limit: Optional[int] = DEFAULT_LIMIT,
-        exclude_native: Optional[bool] = None,
-        max_token_inactivity: Optional[int] = None,
-        min_pair_side_liquidity_usd: Optional[float] = None,
+        to_block: int | None = None,
+        token_addresses: list[str] | None = None,
+        exclude_spam: bool | None = True,
+        exclude_unverified_contracts: bool | None = True,
+        cursor: str | None = None,
+        limit: int | None = DEFAULT_LIMIT,
+        exclude_native: bool | None = None,
+        max_token_inactivity: int | None = None,
+        min_pair_side_liquidity_usd: float | None = None,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Fetch token balances from Moralis.
 
         Args: