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

intentkit/skills/slack/schedule_message.py

@@ -0,0 +1,92 @@
+from datetime import datetime
+from typing import Any, Dict, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.slack.base import SlackBaseTool
+
+
+class SlackScheduleMessageSchema(BaseModel):
+    """Input schema for SlackScheduleMessage."""
+
+    channel_id: str = Field(
+        description="The ID of the channel to send the scheduled message to",
+    )
+    text: str = Field(
+        description="The text content of the message to schedule",
+    )
+    post_at: str = Field(
+        description="The time to send the message in ISO format (e.g., '2023-12-25T10:00:00Z')",
+    )
+    thread_ts: Optional[str] = Field(
+        None,
+        description="The timestamp of the thread to reply to, if sending a thread reply",
+    )
+
+
+class SlackScheduleMessage(SlackBaseTool):
+    """Tool for scheduling messages to be sent to a Slack channel or thread."""
+
+    name: str = "slack_schedule_message"
+    description: str = "Schedule a message to be sent to a Slack channel or thread at a specific time, if you need current time, use skill common_current_time"
+    args_schema: Type[BaseModel] = SlackScheduleMessageSchema
+
+    async def _arun(
+        self,
+        config: RunnableConfig,
+        channel_id: str,
+        text: str,
+        post_at: str,
+        thread_ts: Optional[str] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Run the tool to schedule a Slack message.
+
+        Args:
+            channel_id: The ID of the channel to send the message to
+            text: The text content of the message to schedule
+            post_at: The time to send the message in ISO format
+            thread_ts: The timestamp of the thread to reply to, if sending a thread reply
+
+        Returns:
+            Information about the scheduled message
+
+        Raises:
+            Exception: If an error occurs scheduling the message
+        """
+        context = self.context_from_config(config)
+        client = self.get_client(context.config.get("slack_bot_token"))
+
+        try:
+            # Convert ISO datetime string to Unix timestamp
+            post_datetime = datetime.fromisoformat(post_at.replace("Z", "+00:00"))
+            post_time_unix = int(post_datetime.timestamp())
+
+            # Prepare message parameters
+            message_params = {
+                "channel": channel_id,
+                "text": text,
+                "post_at": post_time_unix,
+            }
+
+            # Add thread_ts if replying to a thread
+            if thread_ts:
+                message_params["thread_ts"] = thread_ts
+
+            # Schedule the message
+            response = client.chat_scheduleMessage(**message_params)
+
+            if response["ok"]:
+                return {
+                    "channel": channel_id,
+                    "scheduled_message_id": response["scheduled_message_id"],
+                    "post_at": post_at,
+                    "text": text,
+                    "thread_ts": thread_ts,
+                }
+            else:
+                raise Exception(f"Error scheduling message: {response.get('error')}")
+
+        except Exception as e:
+            raise Exception(f"Error scheduling message: {str(e)}")

intentkit/skills/slack/schema.json

@@ -0,0 +1,135 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "Slack",
+  "description": "Integration with Slack API enabling workspace communication including channel management, message retrieval, and posting capabilities for team collaboration",
+  "x-icon": "https://ai.service.crestal.dev/skills/slack/slack.jpg",
+  "x-tags": [
+    "Social"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "get_channel": {
+          "type": "string",
+          "title": "Get Channel",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "State of the get_channel skill",
+          "default": "disabled"
+        },
+        "get_message": {
+          "type": "string",
+          "title": "Get Message",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "State of the get_message skill",
+          "default": "disabled"
+        },
+        "schedule_message": {
+          "type": "string",
+          "title": "Schedule Message",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "State of the schedule_message skill",
+          "default": "disabled"
+        },
+        "send_message": {
+          "type": "string",
+          "title": "Send Message",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "State of the send_message skill",
+          "default": "disabled"
+        }
+      },
+      "description": "States for each Slack skill (disabled, public, or private)"
+    },
+    "api_key_provider": {
+      "type": "string",
+      "title": "API Key Provider",
+      "description": "Provider of the API key for AIXBT API service",
+      "enum": [
+        "agent_owner"
+      ],
+      "x-enum-title": [
+        "Owner Provided"
+      ],
+      "default": "agent_owner"
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "if": {
+    "properties": {
+      "api_key_provider": {
+        "const": "agent_owner"
+      }
+    }
+  },
+  "then": {
+    "properties": {
+      "slack_bot_token": {
+        "type": "string",
+        "title": "Slack Bot Token",
+        "x-link": "[Get your API key](https://api.slack.com/)",
+        "x-sensitive": true,
+        "description": "Slack bot token for API access"
+      }
+    },
+    "if": {
+      "properties": {
+        "enabled": {
+          "const": true
+        }
+      }
+    },
+    "then": {
+      "required": [
+        "slack_bot_token"
+      ]
+    }
+  },
+  "additionalProperties": true
+}

intentkit/skills/slack/send_message.py

@@ -0,0 +1,81 @@
+from typing import Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.slack.base import SlackBaseTool, SlackMessage
+
+
+class SlackSendMessageSchema(BaseModel):
+    """Input schema for SlackSendMessage."""
+
+    channel_id: str = Field(
+        description="The ID of the channel to send the message to",
+    )
+    text: str = Field(
+        description="The text content of the message to send",
+    )
+    thread_ts: Optional[str] = Field(
+        None,
+        description="The timestamp of the thread to reply to, if sending a thread reply",
+    )
+
+
+class SlackSendMessage(SlackBaseTool):
+    """Tool for sending messages to a Slack channel or thread."""
+
+    name: str = "slack_send_message"
+    description: str = "Send a message to a Slack channel or thread"
+    args_schema: Type[BaseModel] = SlackSendMessageSchema
+
+    async def _arun(
+        self,
+        config: RunnableConfig,
+        channel_id: str,
+        text: str,
+        thread_ts: Optional[str] = None,
+        **kwargs,
+    ) -> SlackMessage:
+        """Run the tool to send a Slack message.
+
+        Args:
+            channel_id: The ID of the channel to send the message to
+            text: The text content of the message to send
+            thread_ts: The timestamp of the thread to reply to, if sending a thread reply
+
+        Returns:
+            Information about the sent message
+
+        Raises:
+            Exception: If an error occurs sending the message
+        """
+        context = self.context_from_config(config)
+        client = self.get_client(context.config.get("slack_bot_token"))
+
+        try:
+            # Prepare message parameters
+            message_params = {
+                "channel": channel_id,
+                "text": text,
+            }
+
+            # Add thread_ts if replying to a thread
+            if thread_ts:
+                message_params["thread_ts"] = thread_ts
+
+            # Send the message
+            response = client.chat_postMessage(**message_params)
+
+            if response["ok"]:
+                return SlackMessage(
+                    ts=response["ts"],
+                    text=text,
+                    user=response["message"]["user"],
+                    channel=channel_id,
+                    thread_ts=thread_ts,
+                )
+            else:
+                raise Exception(f"Error sending message: {response.get('error')}")
+
+        except Exception as e:
+            raise Exception(f"Error sending message: {str(e)}")

intentkit/skills/system/__init__.py

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

intentkit/skills/system/base.py

@@ -0,0 +1,22 @@
+import secrets
+
+from intentkit.skills.base import IntentKitSkill
+
+
+class SystemBaseTool(IntentKitSkill):
+    """Base class for system-related skills."""
+
+    @property
+    def category(self) -> str:
+        """Return the skill category."""
+        return "system"
+
+    def _generate_api_key(self) -> str:
+        """Generate a new API key using secure random bytes."""
+        # Generate 32 random bytes and convert to hex string
+        return f"sk-{secrets.token_hex(32)}"
+
+    def _generate_public_api_key(self) -> str:
+        """Generate a new public API key using secure random bytes."""
+        # Generate 32 random bytes and convert to hex string
+        return f"pk-{secrets.token_hex(32)}"

intentkit/skills/system/read_agent_api_key.py

@@ -0,0 +1,87 @@
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.system.base import SystemBaseTool
+
+
+class ReadAgentApiKeyInput(BaseModel):
+    """Input model for read_agent_api_key skill."""
+
+    pass
+
+
+class ReadAgentApiKeyOutput(BaseModel):
+    """Output model for read_agent_api_key skill."""
+
+    api_key: str = Field(description="The private API key for the agent (sk-)")
+    api_key_public: str = Field(description="The public API key for the agent (pk-)")
+    is_new: bool = Field(description="Whether new API keys were generated")
+    open_api_base_url: str = Field(description="The base URL for the API")
+    api_endpoint: str = Field(description="The full API endpoint URL")
+
+
+class ReadAgentApiKey(SystemBaseTool):
+    """Skill to retrieve or generate an API key for the agent."""
+
+    name: str = "system_read_agent_api_key"
+    description: str = (
+        "Retrieve the API keys for the agent.  "
+        "Returns both private (sk-) and public (pk-) API keys.  "
+        "Private API key can access all skills (public and owner-only).  "
+        "Public API key can only access public skills.  "
+        "Make sure to tell the user the base URL and endpoint.  "
+        "Tell user in OpenAI sdk or Desktop client like Cherry Studio, input the base URL and API key.  "
+        "Always use markdown code block to wrap the API keys, base URL, and endpoint.  "
+        "Tell user to check more doc in https://github.com/crestalnetwork/intentkit/blob/main/docs/skills/agent_api_key.md "
+    )
+    args_schema = ReadAgentApiKeyInput
+
+    async def _arun(self, config: RunnableConfig, **kwargs) -> ReadAgentApiKeyOutput:
+        """Retrieve or generate an API key for the agent."""
+        # Get context from runnable config to access agent.id
+        context = self.context_from_config(config)
+        agent_id = context.agent.id
+
+        # Get agent data from skill store
+        agent_data = await self.skill_store.get_agent_data(agent_id)
+
+        if not agent_data:
+            raise ValueError(f"Agent data not found for agent_id: {agent_id}")
+
+        # Get API base URL from system config
+        open_api_base_url = self.skill_store.get_system_config("open_api_base_url")
+        api_endpoint = f"{open_api_base_url}/v1/chat/completions"
+
+        # Check if API keys exist
+        if agent_data.api_key and agent_data.api_key_public:
+            return ReadAgentApiKeyOutput(
+                api_key=agent_data.api_key,
+                api_key_public=agent_data.api_key_public,
+                is_new=False,
+                open_api_base_url=open_api_base_url,
+                api_endpoint=api_endpoint,
+            )
+
+        # Generate new API keys if any are missing
+        new_api_key = agent_data.api_key or self._generate_api_key()
+        new_public_api_key = (
+            agent_data.api_key_public or self._generate_public_api_key()
+        )
+
+        # Save the API keys to agent data
+        update_data = {}
+        if not agent_data.api_key:
+            update_data["api_key"] = new_api_key
+        if not agent_data.api_key_public:
+            update_data["api_key_public"] = new_public_api_key
+
+        if update_data:
+            await self.skill_store.set_agent_data(agent_id, update_data)
+
+        return ReadAgentApiKeyOutput(
+            api_key=new_api_key,
+            api_key_public=new_public_api_key,
+            is_new=bool(update_data),
+            open_api_base_url=open_api_base_url,
+            api_endpoint=api_endpoint,
+        )

intentkit/skills/system/regenerate_agent_api_key.py

@@ -0,0 +1,77 @@
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.system.base import SystemBaseTool
+
+
+class RegenerateAgentApiKeyInput(BaseModel):
+    """Input model for regenerate_agent_api_key skill."""
+
+    pass
+
+
+class RegenerateAgentApiKeyOutput(BaseModel):
+    """Output model for regenerate_agent_api_key skill."""
+
+    api_key: str = Field(description="The new private API key for the agent (sk-)")
+    api_key_public: str = Field(
+        description="The new public API key for the agent (pk-)"
+    )
+    previous_key_existed: bool = Field(description="Whether previous API keys existed")
+    open_api_base_url: str = Field(description="The base URL for the API")
+    api_endpoint: str = Field(description="The full API endpoint URL")
+
+
+class RegenerateAgentApiKey(SystemBaseTool):
+    """Skill to regenerate and reset the API key for the agent."""
+
+    name: str = "system_regenerate_agent_api_key"
+    description: str = (
+        "Generate new API keys for the agent, revoke any existing keys.  "
+        "Generates both private (sk-) and public (pk-) API keys.  "
+        "Private API key can access all skills (public and owner-only).  "
+        "Public API key can only access public skills.  "
+        "Make sure to tell the user the base URL and endpoint.  "
+        "Tell user in OpenAI sdk or Desktop client like Cherry Studio, input the base URL and API key.  "
+        "Always use markdown code block to wrap the API keys, base URL, and endpoint.  "
+        "Tell user to check more doc in https://github.com/crestalnetwork/intentkit/blob/main/docs/skills/agent_api_key.md "
+    )
+    args_schema = RegenerateAgentApiKeyInput
+
+    async def _arun(
+        self, config: RunnableConfig, **kwargs
+    ) -> RegenerateAgentApiKeyOutput:
+        """Generate and set a new API key for the agent."""
+        # Get context from runnable config to access agent.id
+        context = self.context_from_config(config)
+        agent_id = context.agent.id
+
+        # Get agent data from skill store
+        agent_data = await self.skill_store.get_agent_data(agent_id)
+
+        if not agent_data:
+            raise ValueError(f"Agent data not found for agent_id: {agent_id}")
+
+        # Get API base URL from system config
+        open_api_base_url = self.skill_store.get_system_config("open_api_base_url")
+        api_endpoint = f"{open_api_base_url}/v1/chat/completions"
+
+        # Check if previous API keys existed
+        previous_key_existed = bool(agent_data.api_key or agent_data.api_key_public)
+
+        # Generate new API keys
+        new_api_key = self._generate_api_key()
+        new_public_api_key = self._generate_public_api_key()
+
+        # Save the new API keys to agent data (overwrites existing)
+        await self.skill_store.set_agent_data(
+            agent_id, {"api_key": new_api_key, "api_key_public": new_public_api_key}
+        )
+
+        return RegenerateAgentApiKeyOutput(
+            api_key=new_api_key,
+            api_key_public=new_public_api_key,
+            previous_key_existed=previous_key_existed,
+            open_api_base_url=open_api_base_url,
+            api_endpoint=api_endpoint,
+        )

intentkit/skills/system/schema.json

@@ -0,0 +1,53 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "System",
+  "description": "System management and configuration skills for agent operations including API key management",
+  "x-icon": "https://ai.service.crestal.dev/skills/system/system.svg",
+  "x-tags": [
+    "System",
+    "Management",
+    "Configuration"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": true
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "read_agent_api_key": {
+          "type": "string",
+          "title": "Read Agent API Key",
+          "enum": [
+            "disabled",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner Only"
+          ],
+          "description": "Retrieve the API key for the agent. If no API key exists, generates and sets a new one.",
+          "default": "private"
+        },
+        "regenerate_agent_api_key": {
+          "type": "string",
+          "title": "Regenerate Agent API Key",
+          "enum": [
+            "disabled",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner Only"
+          ],
+          "description": "Generate a new API key for the agent, replacing any existing key.",
+          "default": "private"
+        }
+      }
+    }
+  }
+}