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

intentkit/skills/github/__init__.py

@@ -0,0 +1,54 @@
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.github.base import GitHubBaseTool
+from intentkit.skills.github.github_search import GitHubSearch
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, GitHubBaseTool] = {}
+
+
+class SkillStates(TypedDict):
+    github_search: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for GitHub skills."""
+
+    states: SkillStates
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[GitHubBaseTool]:
+    """Get all GitHub 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
+    return [get_github_skill(name, store) for name in available_skills]
+
+
+def get_github_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> GitHubBaseTool:
+    """Get a GitHub skill by name."""
+    if name == "github_search":
+        if name not in _cache:
+            _cache[name] = GitHubSearch(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        raise ValueError(f"Unknown GitHub skill: {name}")

intentkit/skills/github/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 GitHubBaseTool(IntentKitSkill):
+    """Base class for GitHub 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 "github"

intentkit/skills/github/github_search.py

@@ -0,0 +1,183 @@
+import logging
+from enum import Enum
+from typing import Type
+
+import httpx
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.github.base import GitHubBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class SearchType(str, Enum):
+    REPOSITORIES = "repositories"
+    USERS = "users"
+    CODE = "code"
+
+
+class GitHubSearchInput(BaseModel):
+    """Input for GitHub search tool."""
+
+    query: str = Field(
+        description="The search query to look up on GitHub.",
+    )
+    search_type: SearchType = Field(
+        description="Type of GitHub search to perform (repositories, users, or code).",
+        default=SearchType.REPOSITORIES,
+    )
+    max_results: int = Field(
+        description="Maximum number of search results to return (1-30).",
+        default=5,
+        ge=1,
+        le=30,
+    )
+
+
+class GitHubSearch(GitHubBaseTool):
+    """Tool for searching GitHub.
+
+    This tool uses GitHub's public REST API to search for repositories, users, and code.
+    No authentication is required as it uses public endpoints.
+
+    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 = "github_search"
+    description: str = (
+        "Search GitHub for repositories, users, or code. Use this tool when you need to find:\n"
+        "- GitHub repositories by name, description, or topics\n"
+        "- GitHub users by username or real name\n"
+        "- Code snippets across GitHub repositories\n"
+        "You must call this tool whenever the user asks about finding something on GitHub."
+    )
+    args_schema: Type[BaseModel] = GitHubSearchInput
+
+    async def _arun(
+        self,
+        query: str,
+        search_type: SearchType = SearchType.REPOSITORIES,
+        max_results: int = 5,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> str:
+        """Implementation of the GitHub search tool.
+
+        Args:
+            query: The search query to look up.
+            search_type: Type of search to perform (repositories, users, or code).
+            max_results: Maximum number of search results to return (1-30).
+            config: The configuration for the tool call.
+
+        Returns:
+            str: Formatted search results based on the search type.
+        """
+        context = self.context_from_config(config)
+        logger.debug(f"github_search.py: Running GitHub search with context {context}")
+
+        # Limit max_results to a reasonable range
+        max_results = max(1, min(max_results, 30))
+
+        headers = {
+            "Accept": "application/vnd.github.v3+json",
+        }
+
+        # Build the search URL based on search type
+        base_url = "https://api.github.com/search"
+        search_url = f"{base_url}/{search_type.value}"
+        logger.debug(f"github_search.py: Searching GitHub at {search_url}")
+
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.get(
+                    search_url,
+                    headers=headers,
+                    params={"q": query, "per_page": max_results},
+                )
+
+                if response.status_code == 403:
+                    rate_limit = response.headers.get(
+                        "X-RateLimit-Remaining", "unknown"
+                    )
+                    reset_time = response.headers.get("X-RateLimit-Reset", "unknown")
+                    logger.warning(
+                        f"github_search.py: Rate limit reached. Remaining: {rate_limit}, Reset: {reset_time}"
+                    )
+                    return (
+                        "GitHub API rate limit reached. Please try again in a few minutes. "
+                        "The rate limit resets every hour for unauthenticated requests."
+                    )
+                elif response.status_code != 200:
+                    logger.error(
+                        f"github_search.py: Error from GitHub API: {response.status_code} - {response.text}"
+                    )
+                    return f"Error searching GitHub: {response.status_code} - {response.text}"
+
+                data = response.json()
+                items = data.get("items", [])
+
+                if not items:
+                    return f"No results found for query: '{query}'"
+
+                # Format results based on search type
+                formatted_results = (
+                    f"GitHub search results for '{query}' ({search_type.value}):\n\n"
+                )
+
+                for i, item in enumerate(items, 1):
+                    if search_type == SearchType.REPOSITORIES:
+                        name = item.get("full_name", "No name")
+                        description = item.get("description", "No description")
+                        url = item.get("html_url", "No URL")
+                        stars = item.get("stargazers_count", 0)
+                        language = item.get("language", "Not specified")
+
+                        formatted_results += f"{i}. {name}\n"
+                        formatted_results += f"Description: {description}\n"
+                        formatted_results += f"Language: {language} | Stars: {stars}\n"
+                        formatted_results += f"URL: {url}\n\n"
+
+                    elif search_type == SearchType.USERS:
+                        login = item.get("login", "No username")
+                        name = item.get("name", "No name")
+                        bio = item.get("bio", "No bio")
+                        url = item.get("html_url", "No URL")
+                        followers = item.get("followers", 0)
+                        public_repos = item.get("public_repos", 0)
+
+                        formatted_results += f"{i}. {login}"
+                        if name:
+                            formatted_results += f" ({name})"
+                        formatted_results += "\n"
+                        if bio:
+                            formatted_results += f"Bio: {bio}\n"
+                        formatted_results += (
+                            f"Followers: {followers} | Public Repos: {public_repos}\n"
+                        )
+                        formatted_results += f"URL: {url}\n\n"
+
+                    elif search_type == SearchType.CODE:
+                        repo = item.get("repository", {}).get(
+                            "full_name", "No repository"
+                        )
+                        path = item.get("path", "No path")
+                        url = item.get("html_url", "No URL")
+
+                        formatted_results += f"{i}. Found in {repo}\n"
+                        formatted_results += f"File: {path}\n"
+                        formatted_results += f"URL: {url}\n\n"
+
+                return formatted_results.strip()
+
+        except httpx.TimeoutException:
+            logger.error("github_search.py: Request timed out")
+            return "The request to GitHub timed out. Please try again later."
+        except Exception as e:
+            logger.error(
+                f"github_search.py: Error searching GitHub: {e}", exc_info=True
+            )
+            return "An error occurred while searching GitHub. Please try again later."

intentkit/skills/github/schema.json

@@ -0,0 +1,59 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "GitHub",
+  "description": "Search capabilities for GitHub repositories, users, and code",
+  "x-icon": "https://ai.service.crestal.dev/skills/github/github.jpg",
+  "x-tags": [
+    "GitHub",
+    "Search",
+    "Code"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "github_search": {
+          "type": "string",
+          "title": "GitHub Search",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Search GitHub for repositories, users, and code",
+          "default": "disabled"
+        }
+      },
+      "description": "States for each GitHub search 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/heurist/__init__.py

@@ -0,0 +1,143 @@
+"""Heurist AI skills."""
+
+import logging
+from typing import NotRequired, TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.heurist.base import HeuristBaseTool
+from intentkit.skills.heurist.image_generation_animagine_xl import (
+    ImageGenerationAnimagineXL,
+)
+from intentkit.skills.heurist.image_generation_arthemy_comics import (
+    ImageGenerationArthemyComics,
+)
+from intentkit.skills.heurist.image_generation_arthemy_real import (
+    ImageGenerationArthemyReal,
+)
+from intentkit.skills.heurist.image_generation_braindance import (
+    ImageGenerationBrainDance,
+)
+from intentkit.skills.heurist.image_generation_cyber_realistic_xl import (
+    ImageGenerationCyberRealisticXL,
+)
+from intentkit.skills.heurist.image_generation_flux_1_dev import ImageGenerationFlux1Dev
+from intentkit.skills.heurist.image_generation_sdxl import ImageGenerationSDXL
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, HeuristBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    image_generation_animagine_xl: SkillState
+    image_generation_arthemy_comics: SkillState
+    image_generation_arthemy_real: SkillState
+    image_generation_braindance: SkillState
+    image_generation_cyber_realistic_xl: SkillState
+    image_generation_flux_1_dev: SkillState
+    image_generation_sdxl: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for Heurist AI skills."""
+
+    states: SkillStates
+    api_key: NotRequired[str]
+    rate_limit_number: NotRequired[int]
+    rate_limit_minutes: NotRequired[int]
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[HeuristBaseTool]:
+    """Get all Heurist AI skills.
+
+    Args:
+        config: The configuration for Heurist AI skills.
+        is_private: Whether to include private skills.
+        store: The skill store for persisting data.
+
+    Returns:
+        A list of Heurist AI 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_heurist_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_heurist_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> HeuristBaseTool:
+    """Get a Heurist AI skill by name.
+
+    Args:
+        name: The name of the skill to get
+        store: The skill store for persisting data
+
+    Returns:
+        The requested Heurist AI skill
+    """
+    if name == "image_generation_animagine_xl":
+        if name not in _cache:
+            _cache[name] = ImageGenerationAnimagineXL(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "image_generation_arthemy_comics":
+        if name not in _cache:
+            _cache[name] = ImageGenerationArthemyComics(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "image_generation_arthemy_real":
+        if name not in _cache:
+            _cache[name] = ImageGenerationArthemyReal(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "image_generation_braindance":
+        if name not in _cache:
+            _cache[name] = ImageGenerationBrainDance(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "image_generation_cyber_realistic_xl":
+        if name not in _cache:
+            _cache[name] = ImageGenerationCyberRealisticXL(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "image_generation_flux_1_dev":
+        if name not in _cache:
+            _cache[name] = ImageGenerationFlux1Dev(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "image_generation_sdxl":
+        if name not in _cache:
+            _cache[name] = ImageGenerationSDXL(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        logger.warning(f"Unknown Heurist skill: {name}")
+        return None

intentkit/skills/heurist/base.py

@@ -0,0 +1,26 @@
+"""Base class for Heurist AI skills."""
+
+from typing import Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill
+
+
+class HeuristBaseTool(IntentKitSkill):
+    """Base class for all Heurist AI skills.
+
+    This class provides common functionality for all Heurist AI skills.
+    """
+
+    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 "heurist"

intentkit/skills/heurist/image_generation_animagine_xl.py

@@ -0,0 +1,162 @@
+import logging
+from typing import Optional, Type
+
+import httpx
+from epyxid import XID
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.heurist.base import HeuristBaseTool
+from intentkit.utils.s3 import store_image
+
+logger = logging.getLogger(__name__)
+
+
+class ImageGenerationAnimagineXLInput(BaseModel):
+    """Input for ImageGenerationAnimagineXL tool."""
+
+    prompt: str = Field(
+        description="Text prompt describing the image to generate.",
+    )
+    neg_prompt: Optional[str] = Field(
+        default="(worst quality: 1.4), bad quality, nsfw",
+        description="Negative prompt describing what to avoid in the generated image.",
+    )
+    width: Optional[int] = Field(
+        default=1024,
+        le=1024,
+        description="Width of the generated image.",
+    )
+    height: Optional[int] = Field(
+        default=680,
+        le=1024,
+        description="Height of the generated image.",
+    )
+
+
+class ImageGenerationAnimagineXL(HeuristBaseTool):
+    """Tool for generating Japanese anime-style images using Heurist AI's AnimagineXL model.
+
+    This tool takes a text prompt and uses Heurist's API to generate
+    a Japanese anime-style image based on the description.
+
+    Attributes:
+        name: The name of the tool.
+        description: A description of what the tool does.
+        args_schema: The schema for the tool's input arguments.
+    """
+
+    name: str = "heurist_image_generation_animagine_xl"
+    description: str = (
+        "Generate Japanese anime-style images using Heurist AI's AnimagineXL model.\n"
+        "Provide a text prompt describing the anime-style image you want to generate.\n"
+        "AnimagineXL specializes in creating high-quality Japanese anime-style illustrations.\n"
+        "If you have height and width, remember to specify them.\n"
+    )
+    args_schema: Type[BaseModel] = ImageGenerationAnimagineXLInput
+
+    async def _arun(
+        self,
+        prompt: str,
+        neg_prompt: Optional[str] = "(worst quality: 1.4), bad quality, nsfw",
+        width: Optional[int] = 1024,
+        height: Optional[int] = 680,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> str:
+        """Implementation of the tool to generate Japanese anime-style images using Heurist AI's AnimagineXL model.
+
+        Args:
+            prompt: Text prompt describing the image to generate.
+            neg_prompt: Negative prompt describing what to avoid in the generated image.
+            width: Width of the generated image.
+            height: Height of the generated image.
+            config: Configuration for the runnable.
+            tool_call_id: The ID of the tool call, can be used for tracking or correlation.
+
+        Returns:
+            str: URL of the generated image.
+        """
+        context = self.context_from_config(config)
+        skill_config = context.config
+
+        # Get the Heurist API key from the skill store
+        if "api_key" in skill_config and skill_config["api_key"]:
+            api_key = skill_config["api_key"]
+            if skill_config.get("rate_limit_number") and skill_config.get(
+                "rate_limit_minutes"
+            ):
+                await self.user_rate_limit_by_category(
+                    context.user_id,
+                    skill_config["rate_limit_number"],
+                    skill_config["rate_limit_minutes"],
+                )
+        else:
+            api_key = self.skill_store.get_system_config("heurist_api_key")
+            await self.user_rate_limit_by_category(context.user_id, 10, 1440)
+
+        # Generate a unique job ID
+        job_id = str(XID())
+
+        # Prepare the request payload
+        payload = {
+            "job_id": job_id,
+            "model_input": {
+                "SD": {
+                    "prompt": prompt,
+                    "neg_prompt": neg_prompt,
+                    "num_iterations": 25,
+                    "width": width,
+                    "height": height,
+                    "guidance_scale": 5,
+                    "seed": -1,
+                }
+            },
+            "model_id": "AnimagineXL",
+            "deadline": 180,
+            "priority": 1,
+        }
+
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        }
+
+        try:
+            # Make the API request
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    "http://sequencer.heurist.xyz/submit_job",
+                    json=payload,
+                    headers=headers,
+                    timeout=180,
+                )
+                logger.debug(f"Heurist API response: {response.text}")
+                response.raise_for_status()
+
+            # Store the image URL
+            image_url = response.text.strip('"')
+            # Generate a key with agent ID as prefix
+            image_key = f"{context.agent.id}/heurist/{job_id}"
+            # Store the image and get the CDN URL
+            stored_url = await store_image(image_url, image_key)
+
+            # Return the stored image URL
+            return stored_url
+
+        except httpx.HTTPStatusError as e:
+            # Extract error details from response
+            try:
+                error_json = e.response.json()
+                error_code = error_json.get("error", "")
+                error_message = error_json.get("message", "")
+                full_error = f"Heurist API error: Error code: {error_code}, Message: {error_message}"
+            except Exception:
+                full_error = f"Heurist API error: {e}"
+
+            logger.error(full_error)
+            raise Exception(full_error)
+
+        except Exception as e:
+            logger.error(f"Error generating image with Heurist: {e}")
+            raise Exception(f"Error generating image with Heurist: {str(e)}")