intentkit 0.6.9.dev2__py3-none-any.whl → 0.6.10.dev1__py3-none-any.whl

intentkit/skills/venice_image/image_vision/image_vision.py

@@ -1,100 +1,98 @@
-import logging
-from typing import Any, Type
-
-from langchain_core.runnables import RunnableConfig
-from pydantic import BaseModel, HttpUrl
-
-from intentkit.skills.base import ToolException
-from intentkit.skills.venice_image.image_vision.image_vision_base import (
-    VeniceImageVisionBaseTool,
-)
-from intentkit.skills.venice_image.image_vision.image_vision_input import (
-    VeniceImageVision,
-)
-from intentkit.skills.venice_image.utils import fetch_image_as_base64
-
-logger = logging.getLogger(__name__)
-
-
-class ImageVision(VeniceImageVisionBaseTool):
-    """
-    Describes an image provided via URL using the Venice AI API.
-    Ideal for understanding the content of an existing image.
-    """
-
-    name: str = "venice_image_vision"
-    description: str = (
-        "Describes an image from a URL using Venice AI.\n"
-        "Provide the public URL of the image to describe.\n"
-        "Returns a descriptive text of the image."
-    )
-    args_schema: Type[BaseModel] = VeniceImageVision
-    # No model_id needed for the generic vision endpoint currently
-
-    async def _arun(
-        self,
-        image_url: HttpUrl,
-        config: RunnableConfig = None,
-        **kwargs,
-    ) -> dict[str, Any]:
-        try:
-            context = self.context_from_config(config)
-
-            await self.apply_venice_rate_limit(context)
-
-            image_base64 = await fetch_image_as_base64(image_url)
-            if not image_base64:
-                error_msg = f"Failed to fetch or validate image from URL: {image_url}"
-                logger.error(error_msg)
-                return {"success": False, "error": error_msg, "result": None}
-
-            payload = {
-                "model": "qwen-2.5-vl",
-                "messages": [
-                    {
-                        "role": "system",
-                        "content": [
-                            {
-                                "type": "text",
-                                "text": (
-                                    "You are an AI model that provides detailed descriptions of images. "
-                                    "When given an image, you must respond with a description that is as comprehensive and detailed as possible. "
-                                    "Focus on identifying all objects, colors, textures, and any other relevant features present in the image. "
-                                    "Provide a thorough and exhaustive account of what is visible in the image."
-                                ),
-                            }
-                        ],
-                    },
-                    {
-                        "role": "user",
-                        "content": [
-                            {
-                                "type": "text",
-                                "text": (
-                                    "Provide an extremely detailed description of the image, focusing on every discernible aspect. "
-                                    "Include information about objects, colors, textures, lighting conditions, artistic style (if applicable), "
-                                    "composition, and any other relevant details that would allow someone to accurately understand and potentially "
-                                    "recreate the image. Be as thorough and comprehensive as possible."
-                                ),
-                            },
-                            {"type": "image_url", "image_url": {"url": str(image_url)}},
-                        ],
-                    },
-                ],
-            }
-
-            result, error = await self.post("api/v1/chat/completions", payload, context)
-            if error:
-                raise ToolException(f"Venice Image Vision API error: {error}")
-            return result
-        except ToolException as e:
-            return {
-                "success": False,
-                "error": f"An unexpected error occurred: {str(e)}",
-            }
-        except Exception as e:
-            logger.error(f"Error in {self.name}: {str(e)}")
-            return {
-                "success": False,
-                "error": f"An unexpected error occurred: {str(e)}",
-            }
+import logging
+from typing import Any, Type
+
+from pydantic import BaseModel, HttpUrl
+
+from intentkit.skills.base import ToolException
+from intentkit.skills.venice_image.image_vision.image_vision_base import (
+    VeniceImageVisionBaseTool,
+)
+from intentkit.skills.venice_image.image_vision.image_vision_input import (
+    VeniceImageVision,
+)
+from intentkit.skills.venice_image.utils import fetch_image_as_base64
+
+logger = logging.getLogger(__name__)
+
+
+class ImageVision(VeniceImageVisionBaseTool):
+    """
+    Describes an image provided via URL using the Venice AI API.
+    Ideal for understanding the content of an existing image.
+    """
+
+    name: str = "venice_image_vision"
+    description: str = (
+        "Describes an image from a URL using Venice AI.\n"
+        "Provide the public URL of the image to describe.\n"
+        "Returns a descriptive text of the image."
+    )
+    args_schema: Type[BaseModel] = VeniceImageVision
+    # No model_id needed for the generic vision endpoint currently
+
+    async def _arun(
+        self,
+        image_url: HttpUrl,
+        **kwargs,
+    ) -> dict[str, Any]:
+        try:
+            context = self.get_context()
+
+            await self.apply_venice_rate_limit(context)
+
+            image_base64 = await fetch_image_as_base64(image_url)
+            if not image_base64:
+                error_msg = f"Failed to fetch or validate image from URL: {image_url}"
+                logger.error(error_msg)
+                return {"success": False, "error": error_msg, "result": None}
+
+            payload = {
+                "model": "qwen-2.5-vl",
+                "messages": [
+                    {
+                        "role": "system",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": (
+                                    "You are an AI model that provides detailed descriptions of images. "
+                                    "When given an image, you must respond with a description that is as comprehensive and detailed as possible. "
+                                    "Focus on identifying all objects, colors, textures, and any other relevant features present in the image. "
+                                    "Provide a thorough and exhaustive account of what is visible in the image."
+                                ),
+                            }
+                        ],
+                    },
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": (
+                                    "Provide an extremely detailed description of the image, focusing on every discernible aspect. "
+                                    "Include information about objects, colors, textures, lighting conditions, artistic style (if applicable), "
+                                    "composition, and any other relevant details that would allow someone to accurately understand and potentially "
+                                    "recreate the image. Be as thorough and comprehensive as possible."
+                                ),
+                            },
+                            {"type": "image_url", "image_url": {"url": str(image_url)}},
+                        ],
+                    },
+                ],
+            }
+
+            result, error = await self.post("api/v1/chat/completions", payload, context)
+            if error:
+                raise ToolException(f"Venice Image Vision API error: {error}")
+            return result
+        except ToolException as e:
+            return {
+                "success": False,
+                "error": f"An unexpected error occurred: {str(e)}",
+            }
+        except Exception as e:
+            logger.error(f"Error in {self.name}: {str(e)}")
+            return {
+                "success": False,
+                "error": f"An unexpected error occurred: {str(e)}",
+            }

intentkit/skills/web_scraper/document_indexer.py

@@ -1,7 +1,6 @@
 import logging
 from typing import Type
 
-from langchain_core.runnables import RunnableConfig
 from pydantic import BaseModel, Field
 
 from intentkit.skills.web_scraper.base import WebScraperBaseTool
@@ -76,15 +75,14 @@ class DocumentIndexer(WebScraperBaseTool):
         chunk_size: int = 1000,
         chunk_overlap: int = 200,
         tags: str = "",
-        config: RunnableConfig = None,
         **kwargs,
     ) -> str:
         """Add text content to the vector database."""
         # Get agent context - throw error if not available
-        if not config:
-            raise ValueError("Configuration is required but not provided")
+        # Configuration is always available in new runtime
+        pass
 
-        context = self.context_from_config(config)
+        context = self.get_context()
         if not context or not context.agent_id:
             raise ValueError("Agent ID is required but not found in configuration")
 

intentkit/skills/web_scraper/scrape_and_index.py

@@ -1,7 +1,6 @@
 import logging
 from typing import List, Type
 
-from langchain_core.runnables import RunnableConfig
 from pydantic import BaseModel, Field
 
 from intentkit.skills.web_scraper.base import WebScraperBaseTool
@@ -75,16 +74,15 @@ class ScrapeAndIndex(WebScraperBaseTool):
         urls: List[str],
         chunk_size: int = DEFAULT_CHUNK_SIZE,
         chunk_overlap: int = DEFAULT_CHUNK_OVERLAP,
-        config: RunnableConfig = None,
         **kwargs,
     ) -> str:
         """Scrape URLs and index content into vector store."""
         try:
             # Get agent context - throw error if not available
-            if not config:
-                raise ValueError("Configuration is required but not provided")
+            # Configuration is always available in new runtime
+            pass
 
-            context = self.context_from_config(config)
+            context = self.get_context()
             if not context or not context.agent_id:
                 raise ValueError("Agent ID is required but not found in configuration")
 
@@ -147,10 +145,10 @@ class ScrapeAndIndex(WebScraperBaseTool):
             # Extract agent_id for error logging if possible
             agent_id = "UNKNOWN"
             try:
-                if config:
-                    context = self.context_from_config(config)
-                    if context and context.agent_id:
-                        agent_id = context.agent_id
+                # TODO: Fix config reference
+                context = self.get_context()
+                if context and context.agent_id:
+                    agent_id = context.agent_id
             except Exception:
                 pass
 
@@ -177,16 +175,15 @@ class QueryIndexedContent(WebScraperBaseTool):
         self,
         query: str,
         max_results: int = 4,
-        config: RunnableConfig = None,
         **kwargs,
     ) -> str:
         """Query the indexed content."""
         try:
             # Get agent context - throw error if not available
-            if not config:
-                raise ValueError("Configuration is required but not provided")
+            # Configuration is always available in new runtime
+            pass
 
-            context = self.context_from_config(config)
+            context = self.get_context()
             if not context or not context.agent_id:
                 raise ValueError("Agent ID is required but not found in configuration")
 
@@ -249,10 +246,10 @@ class QueryIndexedContent(WebScraperBaseTool):
             # Extract agent_id for error logging if possible
             agent_id = "UNKNOWN"
             try:
-                if config:
-                    context = self.context_from_config(config)
-                    if context and context.agent_id:
-                        agent_id = context.agent_id
+                # TODO: Fix config reference
+                context = self.get_context()
+                if context and context.agent_id:
+                    agent_id = context.agent_id
             except Exception:
                 pass
 

intentkit/skills/web_scraper/website_indexer.py

@@ -4,7 +4,6 @@ from urllib.parse import urljoin, urlparse
 
 import httpx
 import openai
-from langchain_core.runnables import RunnableConfig
 from pydantic import BaseModel, Field
 
 from intentkit.skills.web_scraper.base import WebScraperBaseTool
@@ -254,7 +253,7 @@ Extract the URLs now:"""
             from intentkit.skills.openai.base import OpenAIBaseTool
 
             temp_tool = OpenAIBaseTool(skill_store=self.skill_store)
-            api_key = temp_tool.get_api_key(context)
+            api_key = temp_tool.get_api_key()
 
             # Initialize OpenAI client
             client = openai.AsyncOpenAI(api_key=api_key)
@@ -287,7 +286,6 @@ Extract the URLs now:"""
         chunk_overlap: int = DEFAULT_CHUNK_OVERLAP,
         include_patterns: List[str] = None,
         exclude_patterns: List[str] = None,
-        config: RunnableConfig = None,
         **kwargs,
     ) -> str:
         """Discover website sitemaps, extract URLs with AI, and delegate to scrape_and_index."""
@@ -302,11 +300,11 @@ Extract the URLs now:"""
             if not parsed_url.netloc:
                 return "Error: Invalid base URL provided. Please provide a valid URL (e.g., https://example.com)"
 
-            # Get agent context - throw error if not available
-            if not config:
+                # Get agent context - throw error if not available
+                # TODO: Fix config reference
                 raise ValueError("Configuration is required but not provided")
 
-            context = self.context_from_config(config)
+            context = self.get_context()
             if not context or not context.agent_id:
                 raise ValueError("Agent ID is required but not found in configuration")
 
@@ -445,10 +443,10 @@ Extract the URLs now:"""
             # Extract agent_id for error logging if possible
             agent_id = "UNKNOWN"
             try:
-                if config:
-                    context = self.context_from_config(config)
-                    if context and context.agent_id:
-                        agent_id = context.agent_id
+                # TODO: Fix config reference
+                context = self.get_context()
+                if context and context.agent_id:
+                    agent_id = context.agent_id
             except Exception:
                 pass
 

intentkit/skills/xmtp/README.md

@@ -0,0 +1,110 @@
+# XMTP Skills
+
+This skill category provides capabilities for creating XMTP protocol transaction requests that can be sent to users for signing.
+
+## Features
+
+- **xmtp_transfer**: Create ETH or ERC20 token transfer transactions on Base mainnet using XMTP protocol
+
+## Key Innovations
+
+This skill category uses a new response format mechanism:
+
+- `response_format = "content_and_artifact"` in the base class
+- Skills return a tuple `(content_message, List[ChatMessageAttachment])` instead of just a string
+- The `content_message` is sent to the user as conversational text
+- The `ChatMessageAttachment` list contains XMTP transaction data with type "xmtp"
+
+## Requirements
+
+- Agent must be configured for Base mainnet (`network_id: "base-mainnet"`)
+- Agent must have an EVM wallet address configured
+- Only supports Base mainnet (Chain ID: 8453)
+
+## Supported Transfer Types
+
+### ETH Transfers
+- Direct ETH transfers using transaction value
+- No token contract address required
+
+### ERC20 Token Transfers
+- Supports any ERC20 token on Base mainnet
+- Uses `transfer(address,uint256)` function call
+- Requires token contract address
+- Automatically encodes function call data
+
+## Transaction Format
+
+### ETH Transfer Example
+```json
+{
+  "version": "1.0",
+  "from": "0x...",
+  "chainId": "0x2105",
+  "calls": [{
+    "to": "0x...",
+    "value": "0x16345785d8a0000",
+    "data": "0x",
+    "metadata": {
+      "description": "Send 0.1 ETH to address",
+      "transactionType": "transfer",
+      "currency": "ETH",
+      "amount": 100000000000000000,
+      "decimals": 18,
+      "toAddress": "0x..."
+    }
+  }]
+}
+```
+
+### ERC20 Transfer Example
+```json
+{
+  "version": "1.0",
+  "from": "0x...",
+  "chainId": "0x2105",
+  "calls": [{
+    "to": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    "value": "0x0",
+    "data": "0xa9059cbb000000000000000000000000...",
+    "metadata": {
+      "description": "Send 100 USDC to address",
+      "transactionType": "erc20_transfer",
+      "currency": "USDC",
+      "amount": 100000000,
+      "decimals": 6,
+      "toAddress": "0x...",
+      "tokenContract": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+    }
+  }]
+}
+```
+
+## Parameters
+
+- `from_address`: Sender's wallet address (must match agent's EVM wallet)
+- `to_address`: Recipient's wallet address
+- `amount`: Amount to transfer (in human-readable format, e.g., "1.5" for 1.5 tokens)
+- `decimals`: Token decimals (18 for ETH, 6 for USDC, etc.)
+- `currency`: Currency symbol ("ETH", "USDC", "DAI", etc.)
+- `token_contract_address`: Token contract address (optional, leave empty for ETH)
+
+## Usage
+
+```python
+# ETH Transfer:
+# from_address: agent's EVM wallet
+# to_address: recipient address
+# amount: "0.1"
+# decimals: 18
+# currency: "ETH"
+# token_contract_address: None
+
+# USDC Transfer:
+# from_address: agent's EVM wallet
+# to_address: recipient address  
+# amount: "100"
+# decimals: 6
+# currency: "USDC"
+# token_contract_address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+```

intentkit/skills/xmtp/__init__.py

@@ -0,0 +1,82 @@
+"""XMTP skills."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillOwnerState
+from intentkit.skills.xmtp.base import XmtpBaseTool
+from intentkit.skills.xmtp.transfer import XmtpTransfer
+
+# Cache skills at the module level, because they are stateless
+_cache: dict[str, XmtpBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    xmtp_transfer: SkillOwnerState
+
+
+class Config(SkillConfig):
+    """Configuration for XMTP skills."""
+
+    states: SkillStates
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[XmtpBaseTool]:
+    """Get all XMTP skills.
+
+    Args:
+        config: The configuration for XMTP skills.
+        is_private: Whether to include private skills.
+        store: The skill store for persisting data.
+
+    Returns:
+        A list of XMTP 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_xmtp_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_xmtp_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> XmtpBaseTool:
+    """Get an XMTP skill by name.
+
+    Args:
+        name: The name of the skill to get
+        store: The skill store for persisting data
+
+    Returns:
+        The requested XMTP skill
+    """
+    if name == "xmtp_transfer":
+        if name not in _cache:
+            _cache[name] = XmtpTransfer(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        logger.warning(f"Unknown XMTP skill: {name}")
+        return None

intentkit/skills/xmtp/base.py

@@ -0,0 +1,13 @@
+from intentkit.skills.base import IntentKitSkill
+
+
+class XmtpBaseTool(IntentKitSkill):
+    """Base class for XMTP-related skills."""
+
+    # Set response format to content_and_artifact for returning tuple
+    response_format = "content_and_artifact"
+
+    @property
+    def category(self) -> str:
+        """Return the skill category."""
+        return "xmtp"

intentkit/skills/xmtp/schema.json

@@ -0,0 +1,41 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "title": "XMTP",
+    "description": "XMTP protocol skills for creating blockchain transaction requests that can be sent to users for signing",
+    "x-icon": "https://ai.service.crestal.dev/skills/xmtp/xmtp.svg",
+    "x-tags": [
+        "XMTP",
+        "Blockchain",
+        "Transactions",
+        "Web3",
+        "Base"
+    ],
+    "properties": {
+        "enabled": {
+            "type": "boolean",
+            "title": "Enabled",
+            "description": "Whether this skill is enabled",
+            "default": false
+        },
+        "states": {
+            "type": "object",
+            "properties": {
+                "xmtp_transfer": {
+                    "type": "string",
+                    "title": "XMTP Transfer",
+                    "enum": [
+                        "disabled",
+                        "private"
+                    ],
+                    "x-enum-title": [
+                        "Disabled",
+                        "Agent Owner Only"
+                    ],
+                    "description": "Create XMTP transaction requests for transferring ETH or ERC20 tokens on Base mainnet. Supports both native ETH transfers and ERC20 token transfers. Generates wallet_sendCalls transaction data that users can sign.",
+                    "default": "disabled"
+                }
+            }
+        }
+    }
+}