intentkit 0.6.15__tar.gz → 0.6.17__tar.gz

{intentkit-0.6.15 → intentkit-0.6.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.6.15
+Version: 0.6.17
 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.15 → intentkit-0.6.17}/__init__.py

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

{intentkit-0.6.15 → intentkit-0.6.17}/core/engine.py

@@ -44,7 +44,7 @@ from intentkit.core.prompt import (
 from intentkit.core.skill import skill_store
 from intentkit.models.agent import Agent, AgentTable
 from intentkit.models.agent_data import AgentData, AgentQuota
-from intentkit.models.app_setting import AppSetting
+from intentkit.models.app_setting import AppSetting, SystemMessageType
 from intentkit.models.chat import (
     AuthorType,
     ChatMessage,
@@ -298,16 +298,14 @@ async def stream_agent(message: ChatMessageCreate):
         if agent.fee_percentage and agent.fee_percentage > 100:
             owner = await User.get(agent.owner)
             if owner and agent.fee_percentage > 100 + owner.nft_count * 10:
-                error_message_create = ChatMessageCreate(
-                    id=str(XID()),
+                error_message_create = await ChatMessageCreate.from_system_message(
+                    SystemMessageType.SERVICE_FEE_ERROR,
                     agent_id=input.agent_id,
                     chat_id=input.chat_id,
                     user_id=input.user_id,
                     author_id=input.agent_id,
-                    author_type=AuthorType.SYSTEM,
                     thread_type=input.author_type,
                     reply_to=input.id,
-                    message="If you are the owner of this agent, please Update the Service Fee % to be in compliance with the Nation guidelines (Max 100% + 10% per Nation Pass NFT held)",
                     time_cost=time.perf_counter() - start,
                 )
                 error_message = await error_message_create.save()
@@ -336,16 +334,14 @@ async def stream_agent(message: ChatMessageCreate):
             abuse_check = False
         if abuse_check and payer != agent.owner and user_account.free_credits > 0:
             if quota and quota.free_income_daily > 24000:
-                error_message_create = ChatMessageCreate(
-                    id=str(XID()),
+                error_message_create = await ChatMessageCreate.from_system_message(
+                    SystemMessageType.DAILY_USAGE_LIMIT_EXCEEDED,
                     agent_id=input.agent_id,
                     chat_id=input.chat_id,
                     user_id=input.user_id,
                     author_id=input.agent_id,
-                    author_type=AuthorType.SYSTEM,
                     thread_type=input.author_type,
                     reply_to=input.id,
-                    message="This Agent has reached its free CAP income limit for today! Start using paid CAPs or wait until this limit expires in less than 24 hours.",
                     time_cost=time.perf_counter() - start,
                 )
                 error_message = await error_message_create.save()
@@ -356,16 +352,14 @@ async def stream_agent(message: ChatMessageCreate):
         if quota and quota.avg_action_cost > 0:
             avg_count = quota.avg_action_cost
         if not user_account.has_sufficient_credits(avg_count):
-            error_message_create = ChatMessageCreate(
-                id=str(XID()),
+            error_message_create = await ChatMessageCreate.from_system_message(
+                SystemMessageType.INSUFFICIENT_BALANCE,
                 agent_id=input.agent_id,
                 chat_id=input.chat_id,
                 user_id=input.user_id,
                 author_id=input.agent_id,
-                author_type=AuthorType.SYSTEM,
                 thread_type=input.author_type,
                 reply_to=input.id,
-                message="Insufficient balance.",
                 time_cost=time.perf_counter() - start,
             )
             error_message = await error_message_create.save()
@@ -723,17 +717,17 @@ async def stream_agent(message: ChatMessageCreate):
                                 cold_start_cost = 0
                             post_model_message = await post_model_message_create.save()
                             yield post_model_message
-                        error_message_create = ChatMessageCreate(
-                            id=str(XID()),
-                            agent_id=input.agent_id,
-                            chat_id=input.chat_id,
-                            user_id=input.user_id,
-                            author_id=input.agent_id,
-                            author_type=AuthorType.SYSTEM,
-                            thread_type=input.author_type,
-                            reply_to=input.id,
-                            message="Insufficient balance.",
-                            time_cost=0,
+                        error_message_create = (
+                            await ChatMessageCreate.from_system_message(
+                                SystemMessageType.INSUFFICIENT_BALANCE,
+                                agent_id=input.agent_id,
+                                chat_id=input.chat_id,
+                                user_id=input.user_id,
+                                author_id=input.agent_id,
+                                thread_type=input.author_type,
+                                reply_to=input.id,
+                                time_cost=0,
+                            )
                         )
                         error_message = await error_message_create.save()
                         yield error_message
@@ -749,16 +743,14 @@ async def stream_agent(message: ChatMessageCreate):
             f"failed to execute agent: {str(e)}\n{error_traceback}",
             extra={"thread_id": thread_id},
         )
-        error_message_create = ChatMessageCreate(
-            id=str(XID()),
+        error_message_create = await ChatMessageCreate.from_system_message(
+            SystemMessageType.AGENT_INTERNAL_ERROR,
             agent_id=input.agent_id,
             chat_id=input.chat_id,
             user_id=input.user_id,
             author_id=input.agent_id,
-            author_type=AuthorType.SYSTEM,
             thread_type=input.author_type,
             reply_to=input.id,
-            message="Agent Internal Error",
             time_cost=time.perf_counter() - start,
         )
         error_message = await error_message_create.save()
@@ -770,16 +762,14 @@ async def stream_agent(message: ChatMessageCreate):
             f"reached recursion limit: {str(e)}\n{error_traceback}",
             extra={"thread_id": thread_id, "agent_id": input.agent_id},
         )
-        error_message_create = ChatMessageCreate(
-            id=str(XID()),
+        error_message_create = await ChatMessageCreate.from_system_message(
+            SystemMessageType.STEP_LIMIT_EXCEEDED,
             agent_id=input.agent_id,
             chat_id=input.chat_id,
             user_id=input.user_id,
             author_id=input.agent_id,
-            author_type=AuthorType.SYSTEM,
             thread_type=input.author_type,
             reply_to=input.id,
-            message="Step Limit Error",
             time_cost=time.perf_counter() - start,
         )
         error_message = await error_message_create.save()
@@ -791,16 +781,14 @@ async def stream_agent(message: ChatMessageCreate):
             f"failed to execute agent: {str(e)}\n{error_traceback}",
             extra={"thread_id": thread_id, "agent_id": input.agent_id},
         )
-        error_message_create = ChatMessageCreate(
-            id=str(XID()),
+        error_message_create = await ChatMessageCreate.from_system_message(
+            SystemMessageType.AGENT_INTERNAL_ERROR,
             agent_id=input.agent_id,
             chat_id=input.chat_id,
             user_id=input.user_id,
             author_id=input.agent_id,
-            author_type=AuthorType.SYSTEM,
             thread_type=input.author_type,
             reply_to=input.id,
-            message="Agent Internal Error",
             time_cost=time.perf_counter() - start,
         )
         error_message = await error_message_create.save()

{intentkit-0.6.15 → intentkit-0.6.17}/core/prompt.py

@@ -292,7 +292,6 @@ async def build_entrypoint_prompt(agent: Agent, context: AgentContext) -> Option
     Build entrypoint-specific prompt based on context.
 
     Supports different entrypoint types:
-    - Twitter: Uses agent.twitter_entrypoint_prompt
     - Telegram: Uses agent.telegram_entrypoint_prompt
     - Autonomous tasks: Builds task-specific prompt with scheduling info
 

{intentkit-0.6.15 → intentkit-0.6.17}/models/agent.py

@@ -369,23 +369,6 @@ class AgentTable(Base):
         default="base-mainnet",
         comment="Network identifier for CDP integration",
     )
-    # if twitter_enabled, the twitter_entrypoint will be enabled, twitter_config will be checked
-    twitter_entrypoint_enabled = Column(
-        Boolean,
-        nullable=True,
-        default=False,
-        comment="Dangerous, reply all mentions from x.com",
-    )
-    twitter_entrypoint_prompt = Column(
-        String,
-        nullable=True,
-        comment="Extra prompt for twitter entrypoint",
-    )
-    twitter_config = Column(
-        JSON().with_variant(JSONB(), "postgresql"),
-        nullable=True,
-        comment="You must use your own key for twitter entrypoint, it is separated from twitter skills",
-    )
     # if telegram_entrypoint_enabled, the telegram_entrypoint_enabled will be enabled, telegram_config will be checked
     telegram_entrypoint_enabled = Column(
         Boolean,

{intentkit-0.6.15 → intentkit-0.6.17}/models/agent_schema.json

@@ -15,13 +15,13 @@
       "order": 2
     },
     {
-      "id": "examples",
-      "title": "Quick Actions",
+      "id": "onchain",
+      "title": "On-Chain",
       "order": 3
     },
     {
-      "id": "onchain",
-      "title": "On-Chain",
+      "id": "examples",
+      "title": "Quick Actions",
       "order": 4
     },
     {
@@ -73,7 +73,7 @@
       "description": "Ticker symbol of the agent",
       "maxLength": 10,
       "minLength": 1,
-      "x-group": "basic",
+      "x-group": "internal",
       "x-placeholder": "Enter agent ticker"
     },
     "token_address": {
@@ -401,53 +401,6 @@
         }
       }
     },
-    "twitter_entrypoint_enabled": {
-      "title": "Enable X Communication",
-      "type": "boolean",
-      "description": "Agent replies automatically to all X mentions (use cautiously)",
-      "default": false,
-      "x-group": "deprecated"
-    },
-    "twitter_entrypoint_prompt": {
-      "title": "X Entry Prompt",
-      "type": "string",
-      "description": "Extra prompt for X entrypoint",
-      "maxLength": 10000,
-      "x-str-type": "prompt",
-      "x-group": "deprecated"
-    },
-    "twitter_config": {
-      "title": "Enter your X API key",
-      "type": "object",
-      "description": "You must use your own key for X entrypoint, it is separated from X skills",
-      "x-group": "deprecated",
-      "properties": {
-        "consumer_key": {
-          "type": "string",
-          "title": "X API consumer key",
-          "description": "X API consumer key",
-          "maxLength": 100
-        },
-        "consumer_secret": {
-          "type": "string",
-          "title": "X API consumer secret",
-          "description": "X API consumer secret",
-          "maxLength": 100
-        },
-        "access_token": {
-          "type": "string",
-          "title": "X API access token",
-          "description": "X API access token",
-          "maxLength": 100
-        },
-        "access_token_secret": {
-          "type": "string",
-          "title": "X API access token secret",
-          "description": "X API access token secret",
-          "maxLength": 100
-        }
-      }
-    },
     "skills": {
       "title": "Skills",
       "type": "object",
@@ -713,18 +666,22 @@
     "wallet_provider": {
       "title": "Wallet Provider",
       "type": "string",
-      "description": "Provider of the agent's wallet",
+      "description": "Provider of the agent's wallet, choose cdp if you want the agent to have it's own wallet.",
       "enum": [
         "cdp",
         "readonly"
       ],
+      "x-enum-title": [
+        "Coinbase Server Wallet V2",
+        "Readonly Wallet"
+      ],
       "default": "cdp",
       "x-group": "onchain"
     },
     "network_id": {
-      "title": "Network ID",
+      "title": "Default Network",
       "type": "string",
-      "description": "Network identifier",
+      "description": "Default Network",
       "default": "base-mainnet",
       "enum": [
         "ethereum-mainnet",
@@ -739,10 +696,9 @@
         "optimism-sepolia",
         "solana"
       ],
-      "x-group": "internal"
+      "x-group": "onchain"
     }
   },
-  "additionalProperties": false,
   "if": {
     "properties": {
       "wallet_provider": {
@@ -763,5 +719,6 @@
     "required": [
       "readonly_wallet_address"
     ]
-  }
+  },
+  "additionalProperties": true
 }

{intentkit-0.6.15 → intentkit-0.6.17}/models/app_setting.py

@@ -1,16 +1,42 @@
-import json
+import time
 from datetime import datetime, timezone
 from decimal import ROUND_HALF_UP, Decimal
-from typing import Annotated, Any, List
+from enum import Enum
+from typing import Annotated, Any, Dict, List
 
 from intentkit.models.base import Base
 from intentkit.models.db import get_session
-from intentkit.models.redis import get_redis
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 from sqlalchemy import Column, DateTime, String, func, select
 from sqlalchemy.dialects.postgresql import JSON, JSONB
 
 
+class SystemMessageType(str, Enum):
+    """Type of system message."""
+
+    SERVICE_FEE_ERROR = "service_fee_error"
+    DAILY_USAGE_LIMIT_EXCEEDED = "daily_usage_limit_exceeded"
+    INSUFFICIENT_BALANCE = "insufficient_balance"
+    AGENT_INTERNAL_ERROR = "agent_internal_error"
+    STEP_LIMIT_EXCEEDED = "step_limit_exceeded"
+    SKILL_INTERRUPTED = "skill_interrupted"
+
+
+# Default system messages
+DEFAULT_SYSTEM_MESSAGES = {
+    "service_fee_error": "Please lower this Agent's service fee to meet the allowed maximum.",
+    "daily_usage_limit_exceeded": "This Agent has reached its free daily usage limit. Add credits to continue, or wait until tomorrow.",
+    "insufficient_balance": "You don't have enough credits to complete this action.",
+    "agent_internal_error": "Something went wrong. Please try again.",
+    "step_limit_exceeded": "This Agent tried to process too many steps. Try again with @super for higher step limit.",
+    "skill_interrupted": "You were interrupted after executing a skill. Please retry with caution to avoid repeating the skill.",
+}
+
+# In-memory cache for app settings
+_cache: Dict[str, Dict[str, Any]] = {}
+_cache_ttl = 180  # 3 minutes in seconds
+
+
 class AppSettingTable(Base):
     """App settings database table model."""
 
@@ -133,31 +159,23 @@ class AppSetting(BaseModel):
 
     @staticmethod
     async def payment() -> PaymentSettings:
-        """Get payment settings from the database with Redis caching.
+        """Get payment settings from the database with in-memory caching.
 
-        The settings are cached in Redis for 3 minutes.
+        The settings are cached in memory for 3 minutes.
 
         Returns:
             PaymentSettings: Payment settings
         """
-        # Redis cache key for payment settings
-        cache_key = "intentkit:app:settings:payment"
-        cache_ttl = 180  # 3 minutes in seconds
-
-        # Try to get from Redis cache first
-        redis = get_redis()
-        cached_data = await redis.get(cache_key)
-
-        if cached_data:
-            # If found in cache, deserialize and return
-            try:
-                payment_data = json.loads(cached_data)
-                return PaymentSettings(**payment_data)
-            except (json.JSONDecodeError, TypeError):
-                # If cache is corrupted, invalidate it
-                await redis.delete(cache_key)
-
-        # If not in cache or cache is invalid, get from database
+        cache_key = "payment"
+        current_time = time.time()
+
+        # Check if we have cached data and it's still valid
+        if cache_key in _cache:
+            cache_entry = _cache[cache_key]
+            if current_time - cache_entry["timestamp"] < _cache_ttl:
+                return PaymentSettings(**cache_entry["data"])
+
+        # If not in cache or cache is expired, get from database
         async with get_session() as session:
             # Query the database for the payment settings
             stmt = select(AppSettingTable).where(AppSettingTable.key == "payment")
@@ -170,11 +188,56 @@ class AppSetting(BaseModel):
                 # Convert the JSON value to PaymentSettings
                 payment_settings = PaymentSettings(**setting.value)
 
-            # Cache the settings in Redis
-            await redis.set(
-                cache_key,
-                json.dumps(payment_settings.model_dump(mode="json")),
-                ex=cache_ttl,
-            )
+            # Cache the settings in memory
+            _cache[cache_key] = {
+                "data": payment_settings.model_dump(mode="json"),
+                "timestamp": current_time,
+            }
 
             return payment_settings
+
+    @staticmethod
+    async def error_message(message_type: SystemMessageType) -> str:
+        """Get error message from the database with in-memory caching, fallback to default.
+
+        The settings are cached in memory for 3 minutes.
+
+        Args:
+            message_type: The SystemMessageType enum
+
+        Returns:
+            str: Error message from config or default message
+        """
+        cache_key = "errors"
+        current_time = time.time()
+        message_key = message_type.value
+
+        # Check if we have cached data and it's still valid
+        if cache_key in _cache:
+            cache_entry = _cache[cache_key]
+            if current_time - cache_entry["timestamp"] < _cache_ttl:
+                errors_data = cache_entry["data"]
+                if errors_data and message_key in errors_data:
+                    return errors_data[message_key]
+                # Return default message if not found in config
+                return DEFAULT_SYSTEM_MESSAGES[message_key]
+
+        # If not in cache or cache is expired, get from database
+        async with get_session() as session:
+            # Query the database for the errors settings
+            stmt = select(AppSettingTable).where(AppSettingTable.key == "errors")
+            setting = await session.scalar(stmt)
+
+            # If settings don't exist, cache None
+            errors_data = setting.value if setting else None
+
+            # Cache the settings in memory
+            _cache[cache_key] = {
+                "data": errors_data,
+                "timestamp": current_time,
+            }
+
+            # Return configured message if exists, otherwise return default
+            if errors_data and message_key in errors_data:
+                return errors_data[message_key]
+            return DEFAULT_SYSTEM_MESSAGES[message_key]

{intentkit-0.6.15 → intentkit-0.6.17}/models/chat.py

@@ -4,6 +4,7 @@ from enum import Enum
 from typing import Annotated, List, NotRequired, Optional, TypedDict
 
 from epyxid import XID
+from intentkit.models.app_setting import AppSetting, SystemMessageType
 from intentkit.models.base import Base
 from intentkit.models.db import get_session
 from pydantic import BaseModel, ConfigDict, Field
@@ -276,6 +277,10 @@ class ChatMessageTable(Base):
         Boolean,
         nullable=True,
     )
+    error_type = Column(
+        String,
+        nullable=True,
+    )
     created_at = Column(
         DateTime(timezone=True),
         nullable=False,
@@ -361,6 +366,10 @@ class ChatMessageCreate(BaseModel):
         Optional[bool],
         Field(None, description="Optional flag to enable super mode"),
     ]
+    error_type: Annotated[
+        Optional[SystemMessageType],
+        Field(None, description="Optional error type, used when author_type is system"),
+    ]
 
     async def save_in_session(self, db: AsyncSession) -> "ChatMessage":
         """Save the chat message to the database.
@@ -385,6 +394,41 @@ class ChatMessageCreate(BaseModel):
             await db.commit()
             return resp
 
+    @classmethod
+    async def from_system_message(
+        cls,
+        message_type: SystemMessageType,
+        agent_id: str,
+        chat_id: str,
+        user_id: str,
+        author_id: str,
+        thread_type: AuthorType,
+        reply_to: str,
+        time_cost: float = 0.0,
+    ) -> "ChatMessageCreate":
+        """Create a system message.
+
+        Returns:
+            ChatMessageCreate: The created system message
+        """
+
+        # Get error message (configured or default)
+        message = await AppSetting.error_message(message_type)
+
+        return cls(
+            id=str(XID()),
+            agent_id=agent_id,
+            chat_id=chat_id,
+            user_id=user_id,
+            author_id=author_id,
+            author_type=AuthorType.SYSTEM,
+            thread_type=thread_type,
+            reply_to=reply_to,
+            message=message,
+            time_cost=time_cost,
+            error_type=message_type,
+        )
+
 
 class ChatMessage(ChatMessageCreate):
     """Chat message model with all fields including server-generated ones."""

{intentkit-0.6.15 → intentkit-0.6.17}/pyproject.toml

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

{intentkit-0.6.15 → intentkit-0.6.17}/skills/base.py

@@ -13,11 +13,11 @@ from pydantic import (
 from pydantic.v1 import ValidationError as ValidationErrorV1
 from redis.exceptions import RedisError
 
-from intentkit.abstracts.exception import RateLimitExceeded
 from intentkit.abstracts.graph import AgentContext
 from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.models.agent import Agent
 from intentkit.models.redis import get_redis
+from intentkit.utils.error import RateLimitExceeded
 
 SkillState = Literal["disabled", "public", "private"]
 SkillOwnerState = Literal["disabled", "private"]

{intentkit-0.6.15 → intentkit-0.6.17}/skills/cryptocompare/base.py

@@ -7,9 +7,9 @@ from typing import Any, Dict, List, Type
 import httpx
 from pydantic import BaseModel, Field
 
-from intentkit.abstracts.exception import RateLimitExceeded
 from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import IntentKitSkill
+from intentkit.utils.error import RateLimitExceeded
 
 CRYPTO_COMPARE_BASE_URL = "https://min-api.cryptocompare.com"
 

{intentkit-0.6.15 → intentkit-0.6.17}/skills/twitter/base.py

@@ -4,9 +4,9 @@ from typing import Type
 from langchain.tools.base import ToolException
 from pydantic import BaseModel, Field
 
-from intentkit.abstracts.exception import RateLimitExceeded
 from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import IntentKitSkill
+from intentkit.utils.error import RateLimitExceeded
 
 
 class TwitterBaseTool(IntentKitSkill):

{intentkit-0.6.15 → intentkit-0.6.17}/utils/error.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Sequence
+from typing import Optional, Sequence
 
 from fastapi.exceptions import RequestValidationError
 from fastapi.utils import is_body_allowed_for_status_code
@@ -11,6 +11,16 @@ from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY
 
 logger = logging.getLogger(__name__)
 
+# error messages in agent system message response
+
+
+class RateLimitExceeded(Exception):
+    """Rate limit exceeded"""
+
+    def __init__(self, message: Optional[str] = "Rate limit exceeded"):
+        self.message = message
+        super().__init__(self.message)
+
 
 class IntentKitAPIError(Exception):
     def __init__(self, status_code: int, key: str, message: str):

intentkit-0.6.15/abstracts/exception.py

@@ -1,9 +0,0 @@
-from typing import Optional
-
-
-class RateLimitExceeded(Exception):
-    """Rate limit exceeded"""
-
-    def __init__(self, message: Optional[str] = "Rate limit exceeded"):
-        self.message = message
-        super().__init__(self.message)