intentkit 0.6.0.dev13__py3-none-any.whl → 0.6.0.dev15__py3-none-any.whl

intentkit/skills/http/base.py

@@ -0,0 +1,21 @@
+from typing import Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill
+
+
+class HttpBaseTool(IntentKitSkill):
+    """Base class for HTTP client tools."""
+
+    name: str = Field(description="The name of the tool")
+    description: str = Field(description="A description of what the tool does")
+    args_schema: Type[BaseModel]
+    skill_store: SkillStoreABC = Field(
+        description="The skill store for persisting data"
+    )
+
+    @property
+    def category(self) -> str:
+        return "http"

intentkit/skills/http/get.py

@@ -0,0 +1,96 @@
+import logging
+from typing import Any, Dict, Optional, Type
+
+import httpx
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.http.base import HttpBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class HttpGetInput(BaseModel):
+    """Input for HTTP GET request."""
+
+    url: str = Field(description="The URL to send the GET request to")
+    headers: Optional[Dict[str, str]] = Field(
+        description="Optional headers to include in the request",
+        default=None,
+    )
+    params: Optional[Dict[str, Any]] = Field(
+        description="Optional query parameters to include in the request",
+        default=None,
+    )
+    timeout: Optional[float] = Field(
+        description="Request timeout in seconds (default: 30)",
+        default=30.0,
+    )
+
+
+class HttpGet(HttpBaseTool):
+    """Tool for making HTTP GET requests.
+
+    This tool allows you to make HTTP GET requests to any URL with optional
+    headers and query parameters. It returns the response content as a string.
+
+    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 = "http_get"
+    description: str = (
+        "Make an HTTP GET request to a specified URL. "
+        "You can include custom headers and query parameters. "
+        "Returns the response content as text. "
+        "Use this when you need to fetch data from web APIs or websites."
+    )
+    args_schema: Type[BaseModel] = HttpGetInput
+
+    async def _arun(
+        self,
+        url: str,
+        headers: Optional[Dict[str, str]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        timeout: float = 30.0,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> str:
+        """Implementation of the HTTP GET request.
+
+        Args:
+            url: The URL to send the GET request to.
+            headers: Optional headers to include in the request.
+            params: Optional query parameters to include in the request.
+            timeout: Request timeout in seconds.
+            config: The runnable config (unused but required by interface).
+
+        Returns:
+            str: The response content as text, or error message if request fails.
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    url=url,
+                    headers=headers,
+                    params=params,
+                    timeout=timeout,
+                )
+
+                # Raise an exception for bad status codes
+                response.raise_for_status()
+
+                # Return response content
+                return f"Status: {response.status_code}\nContent: {response.text}"
+
+        except httpx.TimeoutException:
+            return f"Error: Request to {url} timed out after {timeout} seconds"
+        except httpx.HTTPStatusError as e:
+            return f"Error: HTTP {e.response.status_code} - {e.response.text}"
+        except httpx.RequestError as e:
+            return f"Error: Failed to connect to {url} - {str(e)}"
+        except Exception as e:
+            logger.error(f"Unexpected error in HTTP GET request: {e}")
+            return f"Error: Unexpected error occurred - {str(e)}"

intentkit/skills/http/http.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" width="100" height="100">
+  <!-- Background -->
+  <rect width="100" height="100" fill="#2563eb" rx="15"/>
+  
+  <!-- HTTP text -->
+  <text x="50" y="35" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="white" text-anchor="middle">HTTP</text>
+  
+  <!-- Arrow indicating request/response -->
+  <path d="M20 50 L35 45 L35 48 L65 48 L65 45 L80 50 L65 55 L65 52 L35 52 L35 55 Z" fill="white"/>
+  
+  <!-- Globe/network icon -->
+  <circle cx="50" cy="75" r="12" fill="none" stroke="white" stroke-width="2"/>
+  <path d="M38 75 Q50 65 62 75 M38 75 Q50 85 62 75" fill="none" stroke="white" stroke-width="1.5"/>
+  <line x1="50" y1="63" x2="50" y2="87" stroke="white" stroke-width="1.5"/>
+</svg>

intentkit/skills/http/post.py

@@ -0,0 +1,113 @@
+import logging
+from typing import Any, Dict, Optional, Type, Union
+
+import httpx
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.http.base import HttpBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class HttpPostInput(BaseModel):
+    """Input for HTTP POST request."""
+
+    url: str = Field(description="The URL to send the POST request to")
+    data: Optional[Union[Dict[str, Any], str]] = Field(
+        description="The data to send in the request body. Can be a dictionary (will be sent as JSON) or a string",
+        default=None,
+    )
+    headers: Optional[Dict[str, str]] = Field(
+        description="Optional headers to include in the request",
+        default=None,
+    )
+    params: Optional[Dict[str, Any]] = Field(
+        description="Optional query parameters to include in the request",
+        default=None,
+    )
+    timeout: Optional[float] = Field(
+        description="Request timeout in seconds (default: 30)",
+        default=30.0,
+    )
+
+
+class HttpPost(HttpBaseTool):
+    """Tool for making HTTP POST requests.
+
+    This tool allows you to make HTTP POST requests to any URL with optional
+    headers, query parameters, and request body data. It returns the response content as a string.
+
+    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 = "http_post"
+    description: str = (
+        "Make an HTTP POST request to a specified URL. "
+        "You can include custom headers, query parameters, and request body data. "
+        "Data can be provided as a dictionary (sent as JSON) or as a string. "
+        "Returns the response content as text. "
+        "Use this when you need to send data to web APIs or submit forms."
+    )
+    args_schema: Type[BaseModel] = HttpPostInput
+
+    async def _arun(
+        self,
+        url: str,
+        data: Optional[Union[Dict[str, Any], str]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        timeout: float = 30.0,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> str:
+        """Implementation of the HTTP POST request.
+
+        Args:
+            url: The URL to send the POST request to.
+            data: The data to send in the request body.
+            headers: Optional headers to include in the request.
+            params: Optional query parameters to include in the request.
+            timeout: Request timeout in seconds.
+            config: The runnable config (unused but required by interface).
+
+        Returns:
+            str: The response content as text, or error message if request fails.
+        """
+        try:
+            # Prepare headers
+            request_headers = headers or {}
+
+            # If data is a dictionary, send as JSON
+            if isinstance(data, dict):
+                if "content-type" not in {k.lower() for k in request_headers.keys()}:
+                    request_headers["Content-Type"] = "application/json"
+
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    url=url,
+                    json=data if isinstance(data, dict) else None,
+                    content=data if isinstance(data, str) else None,
+                    headers=request_headers,
+                    params=params,
+                    timeout=timeout,
+                )
+
+                # Raise an exception for bad status codes
+                response.raise_for_status()
+
+                # Return response content
+                return f"Status: {response.status_code}\nContent: {response.text}"
+
+        except httpx.TimeoutException:
+            return f"Error: Request to {url} timed out after {timeout} seconds"
+        except httpx.HTTPStatusError as e:
+            return f"Error: HTTP {e.response.status_code} - {e.response.text}"
+        except httpx.RequestError as e:
+            return f"Error: Failed to connect to {url} - {str(e)}"
+        except Exception as e:
+            logger.error(f"Unexpected error in HTTP POST request: {e}")
+            return f"Error: Unexpected error occurred - {str(e)}"

intentkit/skills/http/put.py

@@ -0,0 +1,113 @@
+import logging
+from typing import Any, Dict, Optional, Type, Union
+
+import httpx
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.http.base import HttpBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class HttpPutInput(BaseModel):
+    """Input for HTTP PUT request."""
+
+    url: str = Field(description="The URL to send the PUT request to")
+    data: Optional[Union[Dict[str, Any], str]] = Field(
+        description="The data to send in the request body. Can be a dictionary (will be sent as JSON) or a string",
+        default=None,
+    )
+    headers: Optional[Dict[str, str]] = Field(
+        description="Optional headers to include in the request",
+        default=None,
+    )
+    params: Optional[Dict[str, Any]] = Field(
+        description="Optional query parameters to include in the request",
+        default=None,
+    )
+    timeout: Optional[float] = Field(
+        description="Request timeout in seconds (default: 30)",
+        default=30.0,
+    )
+
+
+class HttpPut(HttpBaseTool):
+    """Tool for making HTTP PUT requests.
+
+    This tool allows you to make HTTP PUT requests to any URL with optional
+    headers, query parameters, and request body data. It returns the response content as a string.
+
+    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 = "http_put"
+    description: str = (
+        "Make an HTTP PUT request to a specified URL. "
+        "You can include custom headers, query parameters, and request body data. "
+        "Data can be provided as a dictionary (sent as JSON) or as a string. "
+        "Returns the response content as text. "
+        "Use this when you need to update or replace data on web APIs."
+    )
+    args_schema: Type[BaseModel] = HttpPutInput
+
+    async def _arun(
+        self,
+        url: str,
+        data: Optional[Union[Dict[str, Any], str]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        timeout: float = 30.0,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> str:
+        """Implementation of the HTTP PUT request.
+
+        Args:
+            url: The URL to send the PUT request to.
+            data: The data to send in the request body.
+            headers: Optional headers to include in the request.
+            params: Optional query parameters to include in the request.
+            timeout: Request timeout in seconds.
+            config: The runnable config (unused but required by interface).
+
+        Returns:
+            str: The response content as text, or error message if request fails.
+        """
+        try:
+            # Prepare headers
+            request_headers = headers or {}
+
+            # If data is a dictionary, send as JSON
+            if isinstance(data, dict):
+                if "content-type" not in {k.lower() for k in request_headers.keys()}:
+                    request_headers["Content-Type"] = "application/json"
+
+            async with httpx.AsyncClient() as client:
+                response = await client.put(
+                    url=url,
+                    json=data if isinstance(data, dict) else None,
+                    content=data if isinstance(data, str) else None,
+                    headers=request_headers,
+                    params=params,
+                    timeout=timeout,
+                )
+
+                # Raise an exception for bad status codes
+                response.raise_for_status()
+
+                # Return response content
+                return f"Status: {response.status_code}\nContent: {response.text}"
+
+        except httpx.TimeoutException:
+            return f"Error: Request to {url} timed out after {timeout} seconds"
+        except httpx.HTTPStatusError as e:
+            return f"Error: HTTP {e.response.status_code} - {e.response.text}"
+        except httpx.RequestError as e:
+            return f"Error: Failed to connect to {url} - {str(e)}"
+        except Exception as e:
+            logger.error(f"Unexpected error in HTTP PUT request: {e}")
+            return f"Error: Unexpected error occurred - {str(e)}"

intentkit/skills/http/schema.json

@@ -0,0 +1,92 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "HTTP Client",
+  "description": "HTTP client skills for making web requests",
+  "x-icon": "https://ai.service.crestal.dev/skills/http/http.jpg",
+  "x-tags": [
+    "HTTP",
+    "Web",
+    "API",
+    "Client"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": true
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "http_get": {
+          "type": "string",
+          "title": "HTTP GET",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Make HTTP GET requests to fetch data from web APIs and websites",
+          "default": "private"
+        },
+        "http_post": {
+          "type": "string",
+          "title": "HTTP POST",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Make HTTP POST requests to send data to web APIs and submit forms",
+          "default": "private"
+        },
+        "http_put": {
+          "type": "string",
+          "title": "HTTP PUT",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Make HTTP PUT requests to update or replace data on web APIs",
+          "default": "private"
+        }
+      },
+      "description": "States for each HTTP client skill (disabled, public, or private)"
+    },
+    "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/lifi/token_execute.py

@@ -129,7 +129,7 @@ class TokenExecute(LiFiBaseTool):
 
             # Get agent context for CDP wallet
             context = self.context_from_config(config)
-            agent_id = context.agent.id
+            agent_id = context.agent_id
 
             self.logger.info(
                 f"Executing LiFi transfer: {from_amount} {from_token} on {from_chain} -> {to_token} on {to_chain}"

intentkit/skills/openai/dalle_image_generation.py

@@ -109,7 +109,7 @@ class DALLEImageGeneration(OpenAIBaseTool):
             image_url = image_url.strip('"')
 
             # Generate a key with agent ID as prefix
-            image_key = f"{context.agent.id}/dalle/{job_id}"
+            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)

intentkit/skills/openai/gpt_image_generation.py

@@ -133,7 +133,7 @@ class GPTImageGeneration(OpenAIBaseTool):
             image_bytes = base64.b64decode(base64_image)
 
             # Generate a key with agent ID as prefix
-            image_key = f"{context.agent.id}/gpt-image/{job_id}"
+            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)

intentkit/skills/openai/gpt_image_to_image.py

@@ -157,7 +157,7 @@ class GPTImageToImage(OpenAIBaseTool):
                 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}"
+                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)

intentkit/skills/supabase/__init__.py

@@ -0,0 +1,116 @@
+"""Supabase skills."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.supabase.base import SupabaseBaseTool
+from intentkit.skills.supabase.delete_data import SupabaseDeleteData
+from intentkit.skills.supabase.fetch_data import SupabaseFetchData
+from intentkit.skills.supabase.insert_data import SupabaseInsertData
+from intentkit.skills.supabase.invoke_function import SupabaseInvokeFunction
+from intentkit.skills.supabase.update_data import SupabaseUpdateData
+from intentkit.skills.supabase.upsert_data import SupabaseUpsertData
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, SupabaseBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    fetch_data: SkillState
+    insert_data: SkillState
+    update_data: SkillState
+    upsert_data: SkillState
+    delete_data: SkillState
+    invoke_function: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for Supabase skills."""
+
+    states: SkillStates
+    supabase_url: str
+    supabase_key: str
+    public_write_tables: str = ""
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[SupabaseBaseTool]:
+    """Get all Supabase 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_supabase_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_supabase_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> SupabaseBaseTool:
+    """Get a Supabase skill by name.
+
+    Args:
+        name: The name of the skill to get
+        store: The skill store for persisting data
+
+    Returns:
+        The requested Supabase skill
+    """
+    if name == "fetch_data":
+        if name not in _cache:
+            _cache[name] = SupabaseFetchData(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "insert_data":
+        if name not in _cache:
+            _cache[name] = SupabaseInsertData(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "update_data":
+        if name not in _cache:
+            _cache[name] = SupabaseUpdateData(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "upsert_data":
+        if name not in _cache:
+            _cache[name] = SupabaseUpsertData(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "delete_data":
+        if name not in _cache:
+            _cache[name] = SupabaseDeleteData(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "invoke_function":
+        if name not in _cache:
+            _cache[name] = SupabaseInvokeFunction(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        logger.warning(f"Unknown Supabase skill: {name}")
+        return None

intentkit/skills/supabase/base.py

@@ -0,0 +1,72 @@
+from typing import Type
+
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill, SkillContext
+
+
+class SupabaseBaseTool(IntentKitSkill):
+    """Base class for Supabase tools."""
+
+    name: str = Field(description="The name of the tool")
+    description: str = Field(description="A description of what the tool does")
+    args_schema: Type[BaseModel]
+    skill_store: SkillStoreABC = Field(
+        description="The skill store for persisting data"
+    )
+
+    @property
+    def category(self) -> str:
+        return "supabase"
+
+    def get_supabase_config(self, config: dict) -> tuple[str, str]:
+        """Get Supabase URL and key from config.
+
+        Args:
+            config: The agent configuration
+
+        Returns:
+            Tuple of (supabase_url, supabase_key)
+
+        Raises:
+            ValueError: If required config is missing
+        """
+        supabase_url = config.get("supabase_url")
+        supabase_key = config.get("supabase_key")
+
+        if not supabase_url:
+            raise ValueError("supabase_url is required in config")
+        if not supabase_key:
+            raise ValueError("supabase_key is required in config")
+
+        return supabase_url, supabase_key
+
+    def validate_table_access(self, table: str, context: SkillContext) -> None:
+        """Validate if the table can be accessed for write operations in public mode.
+
+        Args:
+            table: The table name to validate
+            context: The skill context containing configuration and mode info
+
+        Raises:
+            ToolException: If table access is not allowed in public mode
+        """
+        # If in private mode (owner mode), no restrictions apply
+        if context.is_private:
+            return
+
+        # In public mode, check if table is in allowed list
+        public_write_tables = context.config.get("public_write_tables", "")
+        if not public_write_tables:
+            return
+
+        allowed_tables = [
+            t.strip() for t in public_write_tables.split(",") if t.strip()
+        ]
+        if table not in allowed_tables:
+            raise ToolException(
+                f"Table '{table}' is not allowed for public write operations. "
+                f"Allowed tables: {', '.join(allowed_tables)}"
+            )