intentkit 0.6.0.dev14__tar.gz → 0.6.0.dev15__tar.gz

{intentkit-0.6.0.dev14 → intentkit-0.6.0.dev15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.6.0.dev14
+Version: 0.6.0.dev15
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestal-network/intentkit
 Project-URL: Repository, https://github.com/crestal-network/intentkit

{intentkit-0.6.0.dev14 → intentkit-0.6.0.dev15}/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.6.0-dev.14"
+__version__ = "0.6.0-dev.15"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

{intentkit-0.6.0.dev14 → intentkit-0.6.0.dev15}/models/agent_schema.json

@@ -535,6 +535,10 @@
           "title": "System",
           "$ref": "../skills/system/schema.json"
         },
+        "http": {
+          "title": "HTTP Client",
+          "$ref": "../skills/http/schema.json"
+        },
         "web_scraper": {
           "title": "Web Scraper & Content Indexing",
           "$ref": "../skills/web_scraper/schema.json"
@@ -567,6 +571,10 @@
           "title": "Slack",
           "$ref": "../skills/slack/schema.json"
         },
+        "supabase": {
+          "title": "Supabase",
+          "$ref": "../skills/supabase/schema.json"
+        },
         "venice_audio": {
           "title": "Venice Audio",
           "$ref": "../skills/venice_audio/schema.json"

{intentkit-0.6.0.dev14 → intentkit-0.6.0.dev15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intentkit"
-version = "0.6.0-dev.14"
+version = "0.6.0-dev.15"
 description = "Intent-based AI Agent Platform - Core Package"
 authors = [{ name = "hyacinthus", email = "hyacinthus@gmail.com" }]
 requires-python = ">=3.12"

intentkit-0.6.0.dev15/skills/http/README.md

@@ -0,0 +1,78 @@
+# HTTP Client Skills
+
+This skill category provides HTTP client functionality for making web requests using the httpx async client library.
+
+## Available Skills
+
+### http_get
+Make HTTP GET requests to fetch data from web APIs and websites.
+
+**Parameters:**
+- `url` (string, required): The URL to send the GET request to
+- `headers` (dict, optional): Custom headers to include in the request
+- `params` (dict, optional): Query parameters to include in the request
+- `timeout` (float, optional): Request timeout in seconds (default: 30)
+
+**Example usage:**
+```
+Fetch data from https://api.example.com/users with timeout of 10 seconds
+```
+
+### http_post
+Make HTTP POST requests to send data to web APIs and submit forms.
+
+**Parameters:**
+- `url` (string, required): The URL to send the POST request to
+- `data` (dict or string, optional): The data to send in the request body
+- `headers` (dict, optional): Custom headers to include in the request
+- `params` (dict, optional): Query parameters to include in the request
+- `timeout` (float, optional): Request timeout in seconds (default: 30)
+
+**Example usage:**
+```
+Send a POST request to https://api.example.com/users with JSON data {"name": "John", "email": "john@example.com"}
+```
+
+### http_put
+Make HTTP PUT requests to update or replace data on web APIs.
+
+**Parameters:**
+- `url` (string, required): The URL to send the PUT request to
+- `data` (dict or string, optional): The data to send in the request body
+- `headers` (dict, optional): Custom headers to include in the request
+- `params` (dict, optional): Query parameters to include in the request
+- `timeout` (float, optional): Request timeout in seconds (default: 30)
+
+**Example usage:**
+```
+Update user data at https://api.example.com/users/123 with {"name": "Jane Doe"}
+```
+
+## Features
+
+- **Async Support**: All HTTP operations are asynchronous using httpx
+- **Automatic JSON Handling**: Dictionary data is automatically sent as JSON with proper Content-Type headers
+- **Error Handling**: Comprehensive error handling for timeouts, HTTP errors, and connection issues
+- **Flexible Data Types**: Support for both JSON (dict) and raw string data in POST/PUT requests
+- **Custom Headers**: Support for custom headers in all request types
+- **Query Parameters**: Support for URL query parameters
+- **Configurable Timeouts**: Customizable request timeouts
+
+## Configuration
+
+Each skill can be configured with one of three states:
+- `disabled`: Skill is not available
+- `public`: Available to both agent owner and all users
+- `private`: Available only to the agent owner
+
+## Natural Language Usage
+
+These skills are designed to work seamlessly with natural language instructions:
+
+- "Get the weather data from the API"
+- "Send a POST request to create a new user"
+- "Update the user profile using PUT request"
+- "Fetch the latest news from the RSS feed"
+- "Submit the form data to the webhook"
+
+The AI agent will automatically select the appropriate HTTP method and construct the proper request based on your natural language description.

intentkit-0.6.0.dev15/skills/http/__init__.py

@@ -0,0 +1,100 @@
+"""HTTP client skills."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.http.base import HttpBaseTool
+from intentkit.skills.http.get import HttpGet
+from intentkit.skills.http.post import HttpPost
+from intentkit.skills.http.put import HttpPut
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, HttpBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    """Type definition for HTTP skill states."""
+
+    http_get: SkillState
+    http_post: SkillState
+    http_put: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for HTTP client skills."""
+
+    states: SkillStates
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[HttpBaseTool]:
+    """Get all HTTP client skills.
+
+    Args:
+        config: The configuration for HTTP client skills.
+        is_private: Whether to include private skills.
+        store: The skill store for persisting data.
+
+    Returns:
+        A list of HTTP client 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_http_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_http_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> HttpBaseTool:
+    """Get an HTTP client skill by name.
+
+    Args:
+        name: The name of the skill to get
+        store: The skill store for persisting data
+
+    Returns:
+        The requested HTTP client skill
+    """
+    if name == "http_get":
+        if name not in _cache:
+            _cache[name] = HttpGet(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "http_post":
+        if name not in _cache:
+            _cache[name] = HttpPost(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "http_put":
+        if name not in _cache:
+            _cache[name] = HttpPut(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        logger.warning(f"Unknown HTTP skill: {name}")
+        return None

intentkit-0.6.0.dev15/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-0.6.0.dev15/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-0.6.0.dev15/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-0.6.0.dev15/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-0.6.0.dev15/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-0.6.0.dev15/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
+}