intentkit 0.6.13.dev2__py3-none-any.whl → 0.8.17__py3-none-any.whl

intentkit/models/app_setting.py

@@ -1,16 +1,42 @@
-import json
-from datetime import datetime, timezone
+import time
+from datetime import UTC, datetime
 from decimal import ROUND_HALF_UP, Decimal
-from typing import Annotated, Any, List
+from enum import Enum
+from typing import Annotated, Any
 
 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."""
 
@@ -33,7 +59,7 @@ class AppSettingTable(Base):
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
-        onupdate=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(UTC),
     )
 
 
@@ -91,7 +117,7 @@ class PaymentSettings(BaseModel):
         Field(default=False, description="Whether agent whitelist is enabled"),
     ]
     agent_whitelist: Annotated[
-        List[str],
+        list[str],
         Field(default_factory=list, description="List of whitelisted agent IDs"),
     ]
 
@@ -107,7 +133,7 @@ class PaymentSettings(BaseModel):
         """Round decimal values to 4 decimal places."""
         if isinstance(v, Decimal):
             return v.quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
-        elif isinstance(v, (int, float)):
+        elif isinstance(v, int | float):
             return Decimal(str(v)).quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
         return v
 
@@ -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/models/chat.py

@@ -1,9 +1,12 @@
-from datetime import datetime, timezone
+from __future__ import annotations
+
+from datetime import UTC, datetime
 from decimal import Decimal
 from enum import Enum
-from typing import Annotated, List, NotRequired, Optional, TypedDict
+from typing import Annotated, NotRequired, 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
@@ -42,10 +45,12 @@ class AuthorType(str, Enum):
     SKILL = "skill"
     TELEGRAM = "telegram"
     TWITTER = "twitter"
+    DISCORD = "discord"
     WEB = "web"
     SYSTEM = "system"
     API = "api"
     XMTP = "xmtp"
+    X402 = "x402"
 
 
 class ChatMessageAttachment(TypedDict):
@@ -63,7 +68,7 @@ class ChatMessageAttachment(TypedDict):
         ),
     ]
     url: Annotated[
-        Optional[str],
+        str | None,
         Field(
             ...,
             description="URL of the attachment",
@@ -71,7 +76,7 @@ class ChatMessageAttachment(TypedDict):
         ),
     ]
     json: Annotated[
-        Optional[dict],
+        dict | None,
         Field(
             None,
             description="JSON data of the attachment",
@@ -112,7 +117,7 @@ class ChatMessageRequest(BaseModel):
         ),
     ]
     app_id: Annotated[
-        Optional[str],
+        str | None,
         Field(
             None,
             description="Optional application identifier",
@@ -139,21 +144,21 @@ class ChatMessageRequest(BaseModel):
         ),
     ]
     search_mode: Annotated[
-        Optional[bool],
+        bool | None,
         Field(
             None,
             description="Optional flag to enable search mode",
         ),
     ]
     super_mode: Annotated[
-        Optional[bool],
+        bool | None,
         Field(
             None,
             description="Optional flag to enable super mode",
         ),
     ]
     attachments: Annotated[
-        Optional[List[ChatMessageAttachment]],
+        list[ChatMessageAttachment] | None,
         Field(
             None,
             description="Optional list of attachments (links, images, or files)",
@@ -276,6 +281,10 @@ class ChatMessageTable(Base):
         Boolean,
         nullable=True,
     )
+    error_type = Column(
+        String,
+        nullable=True,
+    )
     created_at = Column(
         DateTime(timezone=True),
         nullable=False,
@@ -303,29 +312,29 @@ class ChatMessageCreate(BaseModel):
     ]
     chat_id: Annotated[str, Field(description="ID of the chat this message belongs to")]
     user_id: Annotated[
-        Optional[str],
+        str | None,
         Field(description="ID of the user this message belongs to or reply to"),
     ]
     author_id: Annotated[str, Field(description="ID of the message author")]
     author_type: Annotated[AuthorType, Field(description="Type of the message author")]
     model: Annotated[
-        Optional[str], Field(None, description="LLM model used if applicable")
+        str | None, Field(None, description="LLM model used if applicable")
     ]
     thread_type: Annotated[
-        Optional[AuthorType],
+        AuthorType | None,
         Field(None, description="Author Type of the message thread start"),
     ]
     reply_to: Annotated[
-        Optional[str],
+        str | None,
         Field(None, description="ID of the message this message is a reply to"),
     ]
     message: Annotated[str, Field(description="Content of the message")]
     attachments: Annotated[
-        Optional[List[ChatMessageAttachment]],
+        list[ChatMessageAttachment] | None,
         Field(None, description="List of attachments in the message"),
     ]
     skill_calls: Annotated[
-        Optional[List[ChatMessageSkillCall]],
+        list[ChatMessageSkillCall] | None,
         Field(None, description="Skill call details"),
     ]
     input_tokens: Annotated[
@@ -338,11 +347,11 @@ class ChatMessageCreate(BaseModel):
         float, Field(0.0, description="Time cost for the message in seconds")
     ]
     credit_event_id: Annotated[
-        Optional[str],
+        str | None,
         Field(None, description="ID of the credit event for this message"),
     ]
     credit_cost: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(None, description="Credit cost for the message in credits"),
     ]
     cold_start_cost: Annotated[
@@ -350,17 +359,21 @@ class ChatMessageCreate(BaseModel):
         Field(0.0, description="Cost for the cold start of the message in seconds"),
     ]
     app_id: Annotated[
-        Optional[str],
+        str | None,
         Field(None, description="Optional application identifier"),
     ]
     search_mode: Annotated[
-        Optional[bool],
+        bool | None,
         Field(None, description="Optional flag to enable search mode"),
     ]
     super_mode: Annotated[
-        Optional[bool],
+        bool | None,
         Field(None, description="Optional flag to enable super mode"),
     ]
+    error_type: Annotated[
+        SystemMessageType | None,
+        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 +398,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."""
@@ -459,18 +507,17 @@ class ChatMessage(ChatMessageCreate):
     def sanitize_privacy(self) -> "ChatMessage":
         """Remove sensitive information from the chat message.
 
-        This method clears the message content and removes parameters and response
+        This method clears the skill parameters and response
         from skill calls while preserving the structure and metadata.
 
         Returns:
             ChatMessage: A new ChatMessage instance with sensitive data removed
         """
+        if self.author_type != AuthorType.SKILL:
+            return self
         # Create a copy of the current message
         sanitized_data = self.model_dump()
 
-        # Clear the message content
-        sanitized_data["message"] = ""
-
         # Clear sensitive data from skill calls
         if sanitized_data.get("skill_calls"):
             for skill_call in sanitized_data["skill_calls"]:
@@ -483,7 +530,7 @@ class ChatMessage(ChatMessageCreate):
         return ChatMessage.model_validate(sanitized_data)
 
     @classmethod
-    async def get(cls, message_id: str) -> Optional["ChatMessage"]:
+    async def get(cls, message_id: str) -> ChatMessage | None:
         async with get_session() as db:
             raw = await db.get(ChatMessageTable, message_id)
             if raw:
@@ -526,7 +573,7 @@ class ChatTable(Base):
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
-        onupdate=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(UTC),
     )
 
 
@@ -581,7 +628,7 @@ class Chat(ChatCreate):
     ]
 
     @classmethod
-    async def get(cls, id: str) -> Optional["Chat"]:
+    async def get(cls, id: str) -> "Chat" | None:
         """Get a chat by its ID.
 
         Args:
@@ -645,7 +692,7 @@ class Chat(ChatCreate):
             return self
 
     @classmethod
-    async def get_by_agent_user(cls, agent_id: str, user_id: str) -> List["Chat"]:
+    async def get_by_agent_user(cls, agent_id: str, user_id: str) -> list["Chat"]:
         """Get all chats for a specific agent and user.
 
         Args:

intentkit/models/conversation.py

@@ -5,7 +5,7 @@ related to agent generation sessions.
 """
 
 from datetime import datetime
-from typing import Annotated, List, Optional
+from typing import Annotated
 
 from epyxid import XID
 from intentkit.models.base import Base
@@ -103,7 +103,7 @@ class ConversationProjectCreate(BaseModel):
         ),
     ]
     user_id: Annotated[
-        Optional[str],
+        str | None,
         Field(None, description="User ID associated with this project"),
     ]
 
@@ -144,7 +144,7 @@ class ConversationProject(ConversationProjectCreate):
     ]
 
     @classmethod
-    async def get(cls, project_id: str) -> Optional["ConversationProject"]:
+    async def get(cls, project_id: str) -> "ConversationProject" | None:
         """Get a conversation project by ID."""
         async with get_session() as db:
             result = await db.execute(
@@ -179,8 +179,8 @@ class ConversationProject(ConversationProjectCreate):
 
     @classmethod
     async def get_by_user(
-        cls, user_id: Optional[str] = None, limit: int = 50
-    ) -> List["ConversationProject"]:
+        cls, user_id: str | None = None, limit: int = 50
+    ) -> list["ConversationProject"]:
         """Get conversation projects by user ID."""
         async with get_session() as db:
             query = select(ConversationProjectTable).order_by(
@@ -213,7 +213,7 @@ class ConversationMessageCreate(BaseModel):
     role: Annotated[str, Field(description="Role of the message sender")]
     content: Annotated[str, Field(description="Content of the message")]
     message_metadata: Annotated[
-        Optional[dict],
+        dict | None,
         Field(None, description="Additional metadata for the message"),
     ]
 
@@ -255,8 +255,8 @@ class ConversationMessage(ConversationMessageCreate):
 
     @classmethod
     async def get_by_project(
-        cls, project_id: str, user_id: Optional[str] = None
-    ) -> List["ConversationMessage"]:
+        cls, project_id: str, user_id: str | None = None
+    ) -> list["ConversationMessage"]:
         """Get conversation messages for a project."""
         async with get_session() as db:
             # First check if project exists and user has access