intentkit 0.7.5.dev3__py3-none-any.whl → 0.8.34.dev7__py3-none-any.whl

intentkit/models/redis.py

@@ -1,21 +1,20 @@
 """Redis client module for IntentKit."""
 
 import logging
-from typing import Optional
 
 from redis.asyncio import Redis
 
 logger = logging.getLogger(__name__)
 
 # Global Redis client instance
-_redis_client: Optional[Redis] = None
+_redis_client: Redis | None = None
 
 
 async def init_redis(
     host: str,
     port: int = 6379,
     db: int = 0,
-    password: Optional[str] = None,
+    password: str | None = None,
     ssl: bool = False,
     encoding: str = "utf-8",
     decode_responses: bool = True,
@@ -74,6 +73,9 @@ def get_redis() -> Redis:
     return _redis_client
 
 
+DEFAULT_HEARTBEAT_TTL = 16 * 60
+
+
 async def send_heartbeat(redis_client: Redis, name: str) -> None:
     """Set a heartbeat key in Redis that expires after 16 minutes.
 
@@ -83,7 +85,7 @@ async def send_heartbeat(redis_client: Redis, name: str) -> None:
     """
     try:
         key = f"intentkit:heartbeat:{name}"
-        await redis_client.set(key, 1, ex=190)  # 190 seconds = 3 minutes
+        await redis_client.set(key, 1, ex=DEFAULT_HEARTBEAT_TTL)
     except Exception as e:
         logger.error(f"Failed to send heartbeat for {name}: {e}")
 

intentkit/models/skill.py

@@ -1,15 +1,16 @@
+from __future__ import annotations
+
+import csv
 import json
-from datetime import datetime, timezone
+import logging
+from datetime import UTC, datetime
 from decimal import Decimal
-from typing import Annotated, Any, Dict, Optional
+from pathlib import Path
+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
 from sqlalchemy import (
     Boolean,
-    Column,
     DateTime,
     Integer,
     Numeric,
@@ -19,6 +20,14 @@ from sqlalchemy import (
     select,
 )
 from sqlalchemy.dialects.postgresql import JSON, JSONB
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Mapped, mapped_column
+
+from intentkit.models.base import Base
+from intentkit.models.db import get_session
+from intentkit.models.redis import get_redis
+
+logger = logging.getLogger(__name__)
 
 
 class AgentSkillDataTable(Base):
@@ -26,21 +35,23 @@ class AgentSkillDataTable(Base):
 
     __tablename__ = "agent_skill_data"
 
-    agent_id = Column(String, primary_key=True)
-    skill = Column(String, primary_key=True)
-    key = Column(String, primary_key=True)
-    data = Column(JSON().with_variant(JSONB(), "postgresql"), nullable=True)
-    size = Column(Integer, nullable=False, default=0)
-    created_at = Column(
+    agent_id: Mapped[str] = mapped_column(String, primary_key=True)
+    skill: Mapped[str] = mapped_column(String, primary_key=True)
+    key: Mapped[str] = mapped_column(String, primary_key=True)
+    data: Mapped[dict[str, Any] | None] = mapped_column(
+        JSON().with_variant(JSONB(), "postgresql"), nullable=True
+    )
+    size: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
     )
-    updated_at = Column(
+    updated_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
-        onupdate=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(UTC),
     )
 
 
@@ -52,7 +63,7 @@ class AgentSkillDataCreate(BaseModel):
     agent_id: Annotated[str, Field(description="ID of the agent this data belongs to")]
     skill: Annotated[str, Field(description="Name of the skill this data is for")]
     key: Annotated[str, Field(description="Key for this specific piece of data")]
-    data: Annotated[Dict[str, Any], Field(description="JSON data stored for this key")]
+    data: Annotated[dict[str, Any], Field(description="JSON data stored for this key")]
 
     async def save(self) -> "AgentSkillData":
         """Save or update skill data.
@@ -151,7 +162,7 @@ class AgentSkillData(AgentSkillDataCreate):
             return result or 0
 
     @classmethod
-    async def get(cls, agent_id: str, skill: str, key: str) -> Optional[dict]:
+    async def get(cls, agent_id: str, skill: str, key: str) -> dict | None:
         """Get skill data for an agent.
 
         Args:
@@ -207,54 +218,54 @@ class AgentSkillData(AgentSkillDataCreate):
             await db.commit()
 
 
-class ThreadSkillDataTable(Base):
-    """Database table model for storing skill-specific data for threads."""
+class ChatSkillDataTable(Base):
+    """Database table model for storing skill-specific data for chats."""
 
-    __tablename__ = "thread_skill_data"
+    __tablename__ = "chat_skill_data"
 
-    thread_id = Column(String, primary_key=True)
-    skill = Column(String, primary_key=True)
-    key = Column(String, primary_key=True)
-    agent_id = Column(String, nullable=False)
-    data = Column(JSON().with_variant(JSONB(), "postgresql"), nullable=True)
-    created_at = Column(
+    chat_id: Mapped[str] = mapped_column(String, primary_key=True)
+    skill: Mapped[str] = mapped_column(String, primary_key=True)
+    key: Mapped[str] = mapped_column(String, primary_key=True)
+    agent_id: Mapped[str] = mapped_column(String, nullable=False)
+    data: Mapped[dict[str, Any] | None] = mapped_column(
+        JSON().with_variant(JSONB(), "postgresql"), nullable=True
+    )
+    created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
     )
-    updated_at = Column(
+    updated_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
-        onupdate=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(UTC),
     )
 
 
-class ThreadSkillDataCreate(BaseModel):
-    """Base model for creating thread skill data records."""
+class ChatSkillDataCreate(BaseModel):
+    """Base model for creating chat skill data records."""
 
     model_config = ConfigDict(from_attributes=True)
 
-    thread_id: Annotated[
-        str, Field(description="ID of the thread this data belongs to")
-    ]
+    chat_id: Annotated[str, Field(description="ID of the chat this data belongs to")]
     skill: Annotated[str, Field(description="Name of the skill this data is for")]
     key: Annotated[str, Field(description="Key for this specific piece of data")]
-    agent_id: Annotated[str, Field(description="ID of the agent that owns this thread")]
-    data: Annotated[Dict[str, Any], Field(description="JSON data stored for this key")]
+    agent_id: Annotated[str, Field(description="ID of the agent that owns this chat")]
+    data: Annotated[dict[str, Any], Field(description="JSON data stored for this key")]
 
-    async def save(self) -> "ThreadSkillData":
+    async def save(self) -> "ChatSkillData":
         """Save or update skill data.
 
         Returns:
-            ThreadSkillData: The saved thread skill data instance
+            ChatSkillData: The saved chat skill data instance
         """
         async with get_session() as db:
             record = await db.scalar(
-                select(ThreadSkillDataTable).where(
-                    ThreadSkillDataTable.thread_id == self.thread_id,
-                    ThreadSkillDataTable.skill == self.skill,
-                    ThreadSkillDataTable.key == self.key,
+                select(ChatSkillDataTable).where(
+                    ChatSkillDataTable.chat_id == self.chat_id,
+                    ChatSkillDataTable.skill == self.skill,
+                    ChatSkillDataTable.key == self.key,
                 )
             )
 
@@ -264,18 +275,18 @@ class ThreadSkillDataCreate(BaseModel):
                 record.agent_id = self.agent_id
             else:
                 # Create new record
-                record = ThreadSkillDataTable(**self.model_dump())
+                record = ChatSkillDataTable(**self.model_dump())
             db.add(record)
             await db.commit()
             await db.refresh(record)
-            return ThreadSkillData.model_validate(record)
+            return ChatSkillData.model_validate(record)
 
 
-class ThreadSkillData(ThreadSkillDataCreate):
-    """Model for storing skill-specific data for threads.
+class ChatSkillData(ChatSkillDataCreate):
+    """Model for storing skill-specific data for chats.
 
-    This model uses a composite primary key of (thread_id, skill, key) to store
-    skill-specific data for threads in a flexible way. It also includes agent_id
+    This model uses a composite primary key of (chat_id, skill, key) to store
+    skill-specific data for chats in a flexible way. It also includes agent_id
     as a required field for tracking ownership.
     """
 
@@ -292,11 +303,11 @@ class ThreadSkillData(ThreadSkillDataCreate):
     ]
 
     @classmethod
-    async def get(cls, thread_id: str, skill: str, key: str) -> Optional[dict]:
-        """Get skill data for a thread.
+    async def get(cls, chat_id: str, skill: str, key: str) -> dict | None:
+        """Get skill data for a chat.
 
         Args:
-            thread_id: ID of the thread
+            chat_id: ID of the chat
             skill: Name of the skill
             key: Data key
 
@@ -305,10 +316,10 @@ class ThreadSkillData(ThreadSkillDataCreate):
         """
         async with get_session() as db:
             record = await db.scalar(
-                select(ThreadSkillDataTable).where(
-                    ThreadSkillDataTable.thread_id == thread_id,
-                    ThreadSkillDataTable.skill == skill,
-                    ThreadSkillDataTable.key == key,
+                select(ChatSkillDataTable).where(
+                    ChatSkillDataTable.chat_id == chat_id,
+                    ChatSkillDataTable.skill == skill,
+                    ChatSkillDataTable.key == key,
                 )
             )
         return record.data if record else None
@@ -317,63 +328,135 @@ class ThreadSkillData(ThreadSkillDataCreate):
     async def clean_data(
         cls,
         agent_id: str,
-        thread_id: Annotated[
+        chat_id: Annotated[
             str,
             Field(
                 default="",
-                description="Optional ID of the thread. If provided, only cleans data for that thread.",
+                description="Optional ID of the chat. If provided, only cleans data for that chat.",
             ),
         ],
     ):
-        """Clean all skill data for a thread or agent.
+        """Clean all skill data for a chat or agent.
 
         Args:
             agent_id: ID of the agent
-            thread_id: Optional ID of the thread. If provided, only cleans data for that thread.
-                      If empty, cleans all data for the agent.
+            chat_id: Optional ID of the chat. If provided, only cleans data for that chat.
+                     If empty, cleans all data for the agent.
         """
         async with get_session() as db:
-            if thread_id and thread_id != "":
+            if chat_id and chat_id != "":
                 await db.execute(
-                    delete(ThreadSkillDataTable).where(
-                        ThreadSkillDataTable.agent_id == agent_id,
-                        ThreadSkillDataTable.thread_id == thread_id,
+                    delete(ChatSkillDataTable).where(
+                        ChatSkillDataTable.agent_id == agent_id,
+                        ChatSkillDataTable.chat_id == chat_id,
                     )
                 )
             else:
                 await db.execute(
-                    delete(ThreadSkillDataTable).where(
-                        ThreadSkillDataTable.agent_id == agent_id
+                    delete(ChatSkillDataTable).where(
+                        ChatSkillDataTable.agent_id == agent_id
                     )
                 )
             await db.commit()
 
 
+def _skill_parse_bool(value: str | None) -> bool:
+    if value is None:
+        return False
+    return value.strip().lower() in {"true", "1", "yes"}
+
+
+def _skill_parse_optional_int(value: str | None) -> int | None:
+    if value is None:
+        return None
+    value = value.strip()
+    return int(value) if value else None
+
+
+def _skill_parse_decimal(value: str | None, default: str = "0") -> Decimal:
+    value = (value or "").strip()
+    if not value:
+        value = default
+    return Decimal(value)
+
+
+def _load_default_skills() -> tuple[dict[str, "Skill"], dict[tuple[str, str], "Skill"]]:
+    """Load default skills from CSV into lookup maps."""
+
+    path = Path(__file__).with_name("skills.csv")
+    if not path.exists():
+        logger.warning("Default skills CSV not found at %s", path)
+        return {}, {}
+
+    by_name: dict[str, Skill] = {}
+    by_category_config: dict[tuple[str, str], Skill] = {}
+
+    with path.open(newline="", encoding="utf-8") as csvfile:
+        reader = csv.DictReader(csvfile)
+        for row in reader:
+            try:
+                timestamp = datetime.now(UTC)
+                price_default = row.get("price") or "1"
+                skill = Skill(
+                    name=row["name"],
+                    category=row["category"],
+                    config_name=row.get("config_name") or None,
+                    enabled=_skill_parse_bool(row.get("enabled")),
+                    price_level=_skill_parse_optional_int(row.get("price_level")),
+                    price=_skill_parse_decimal(row.get("price"), default="1"),
+                    price_self_key=_skill_parse_decimal(
+                        row.get("price_self_key"), default=price_default
+                    ),
+                    rate_limit_count=_skill_parse_optional_int(
+                        row.get("rate_limit_count")
+                    ),
+                    rate_limit_minutes=_skill_parse_optional_int(
+                        row.get("rate_limit_minutes")
+                    ),
+                    author=row.get("author") or None,
+                    created_at=timestamp,
+                    updated_at=timestamp,
+                )
+            except Exception as exc:
+                logger.error(
+                    "Failed to load default skill %s: %s", row.get("name"), exc
+                )
+                continue
+
+            by_name[skill.name] = skill
+            if skill.config_name:
+                by_category_config[(skill.category, skill.config_name)] = skill
+
+    return by_name, by_category_config
+
+
 class SkillTable(Base):
     """Database table model for Skill."""
 
     __tablename__ = "skills"
 
-    name = Column(String, primary_key=True)
-    enabled = Column(Boolean, nullable=False, default=True)
-    category = Column(String, nullable=False)
-    config_name = Column(String, nullable=True)
-    price_level = Column(Integer, nullable=True)
-    price = Column(Numeric(22, 4), nullable=False, default=1)
-    price_self_key = Column(Numeric(22, 4), nullable=False, default=1)
-    rate_limit_count = Column(Integer, nullable=True)
-    rate_limit_minutes = Column(Integer, nullable=True)
-    author = Column(String, nullable=True)
-    created_at = Column(
+    name: Mapped[str] = mapped_column(String, primary_key=True)
+    enabled: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True)
+    category: Mapped[str] = mapped_column(String, nullable=False)
+    config_name: Mapped[str | None] = mapped_column(String, nullable=True)
+    price_level: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    price: Mapped[Decimal] = mapped_column(Numeric(22, 4), nullable=False, default=1)
+    price_self_key: Mapped[Decimal] = mapped_column(
+        Numeric(22, 4), nullable=False, default=1
+    )
+    rate_limit_count: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    rate_limit_minutes: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    author: Mapped[str | None] = mapped_column(String, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
     )
-    updated_at = Column(
+    updated_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
-        onupdate=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(UTC),
     )
 
 
@@ -390,10 +473,8 @@ class Skill(BaseModel):
     name: Annotated[str, Field(description="Name of the skill")]
     enabled: Annotated[bool, Field(description="Is this skill enabled?")]
     category: Annotated[str, Field(description="Category of the skill")]
-    config_name: Annotated[Optional[str], Field(description="Config name of the skill")]
-    price_level: Annotated[
-        Optional[int], Field(description="Price level for this skill")
-    ]
+    config_name: Annotated[str | None, Field(description="Config name of the skill")]
+    price_level: Annotated[int | None, Field(description="Price level for this skill")]
     price: Annotated[
         Decimal, Field(description="Price for this skill", default=Decimal("1"))
     ]
@@ -401,11 +482,9 @@ class Skill(BaseModel):
         Decimal,
         Field(description="Price for this skill with self key", default=Decimal("1")),
     ]
-    rate_limit_count: Annotated[Optional[int], Field(description="Rate limit count")]
-    rate_limit_minutes: Annotated[
-        Optional[int], Field(description="Rate limit minutes")
-    ]
-    author: Annotated[Optional[str], Field(description="Author of the skill")]
+    rate_limit_count: Annotated[int | None, Field(description="Rate limit count")]
+    rate_limit_minutes: Annotated[int | None, Field(description="Rate limit minutes")]
+    author: Annotated[str | None, Field(description="Author of the skill")]
     created_at: Annotated[
         datetime, Field(description="Timestamp when this record was created")
     ]
@@ -414,7 +493,7 @@ class Skill(BaseModel):
     ]
 
     @staticmethod
-    async def get(name: str) -> Optional["Skill"]:
+    async def get(name: str) -> Skill | None:
         """Get a skill by name with Redis caching.
 
         The skill is cached in Redis for 3 minutes.
@@ -447,20 +526,23 @@ class Skill(BaseModel):
             stmt = select(SkillTable).where(SkillTable.name == name)
             skill = await session.scalar(stmt)
 
-            # If skill doesn't exist, return None
-            if not skill:
-                return None
-
-            # Convert to Skill model
-            skill_model = Skill.model_validate(skill)
+            # If skill exists in database, convert and cache it
+            if skill:
+                skill_model = Skill.model_validate(skill)
+                await redis.set(cache_key, skill_model.model_dump_json(), ex=cache_ttl)
+                return skill_model
 
-            # Cache the skill in Redis
+        # Fallback to default skills loaded from CSV
+        default_skill = DEFAULT_SKILLS_BY_NAME.get(name)
+        if default_skill:
+            skill_model = default_skill.model_copy(deep=True)
             await redis.set(cache_key, skill_model.model_dump_json(), ex=cache_ttl)
-
             return skill_model
 
+        return None
+
     @staticmethod
-    async def get_by_config_name(category: str, config_name: str) -> Optional["Skill"]:
+    async def get_by_config_name(category: str, config_name: str) -> "Skill" | None:
         """Get a skill by category and config_name.
 
         Args:
@@ -477,9 +559,48 @@ class Skill(BaseModel):
             )
             skill = await session.scalar(stmt)
 
-            # If skill doesn't exist, return None
-            if not skill:
-                return None
+            # If skill exists in database, return it
+            if skill:
+                return Skill.model_validate(skill)
+
+        # Fallback to default skills loaded from CSV
+        default_skill = DEFAULT_SKILLS_BY_CATEGORY_CONFIG.get((category, config_name))
+        if default_skill:
+            return default_skill.model_copy(deep=True)
+
+        return None
+
+    @classmethod
+    async def get_all(cls, session: AsyncSession | None = None) -> list["Skill"]:
+        """Return all skills merged from defaults and database overrides."""
+
+        if session is None:
+            async with get_session() as db:
+                return await cls.get_all(session=db)
+
+        skills: dict[str, Skill] = {
+            name: skill.model_copy(deep=True)
+            for name, skill in DEFAULT_SKILLS_BY_NAME.items()
+        }
+
+        result = await session.execute(select(SkillTable))
+        for row in result.scalars():
+            skill_model = cls.model_validate(row)
+
+            default_skill = DEFAULT_SKILLS_BY_NAME.get(skill_model.name)
+            if default_skill is not None:
+                # Merge database overrides with default skill configuration while
+                # keeping default values for fields that are omitted in the
+                # database (e.g. config_name).
+                skill_model = default_skill.model_copy(
+                    update=skill_model.model_dump(exclude_none=True),
+                    deep=True,
+                )
+
+            skills[skill_model.name] = skill_model
+
+        return list(skills.values())
+
 
-            # Convert to Skill model
-            return Skill.model_validate(skill)
+# Default skills loaded from CSV
+DEFAULT_SKILLS_BY_NAME, DEFAULT_SKILLS_BY_CATEGORY_CONFIG = _load_default_skills()