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

intentkit/models/credit.py

@@ -1,19 +1,15 @@
 import logging
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from decimal import ROUND_HALF_UP, Decimal
 from enum import Enum
-from typing import Annotated, Any, Dict, List, Optional, Tuple
+from typing import Annotated, Any
 
 from epyxid import XID
 from fastapi import HTTPException
-from intentkit.models.app_setting import AppSetting
-from intentkit.models.base import Base
-from intentkit.models.db import get_session
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 from sqlalchemy import (
     ARRAY,
     JSON,
-    Column,
     DateTime,
     Index,
     Numeric,
@@ -23,6 +19,12 @@ from sqlalchemy import (
     update,
 )
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Mapped, mapped_column
+
+from intentkit.models.app_setting import AppSetting
+from intentkit.models.base import Base
+from intentkit.models.db import get_session
+from intentkit.utils.error import IntentKitAPIError
 
 logger = logging.getLogger(__name__)
 
@@ -43,6 +45,7 @@ class OwnerType(str, Enum):
 
     USER = "user"
     AGENT = "agent"
+    TEAM = "team"
     PLATFORM = "platform"
 
 
@@ -69,106 +72,106 @@ class CreditAccountTable(Base):
     __tablename__ = "credit_accounts"
     __table_args__ = (Index("ix_credit_accounts_owner", "owner_type", "owner_id"),)
 
-    id = Column(
+    id: Mapped[str] = mapped_column(
         String,
         primary_key=True,
     )
-    owner_type = Column(
+    owner_type: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    owner_id = Column(
+    owner_id: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    free_quota = Column(
+    free_quota: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    refill_amount = Column(
+    refill_amount: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    free_credits = Column(
+    free_credits: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    reward_credits = Column(
+    reward_credits: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    credits = Column(
+    credits: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    income_at = Column(
+    income_at: Mapped[datetime | None] = mapped_column(
         DateTime(timezone=True),
         nullable=True,
     )
-    expense_at = Column(
+    expense_at: Mapped[datetime | None] = mapped_column(
         DateTime(timezone=True),
         nullable=True,
     )
-    last_event_id = Column(
+    last_event_id: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
     # Total statistics fields
-    total_income = Column(
+    total_income: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    total_free_income = Column(
+    total_free_income: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    total_reward_income = Column(
+    total_reward_income: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    total_permanent_income = Column(
+    total_permanent_income: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    total_expense = Column(
+    total_expense: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    total_free_expense = Column(
+    total_free_expense: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    total_reward_expense = Column(
+    total_reward_expense: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    total_permanent_expense = Column(
+    total_permanent_expense: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    created_at = Column(
+    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),
     )
 
 
@@ -220,15 +223,15 @@ class CreditAccount(BaseModel):
         Field(default=Decimal("0"), description="Credits added through top-ups"),
     ]
     income_at: Annotated[
-        Optional[datetime],
+        datetime | None,
         Field(None, description="Timestamp of the last income transaction"),
     ]
     expense_at: Annotated[
-        Optional[datetime],
+        datetime | None,
         Field(None, description="Timestamp of the last expense transaction"),
     ]
     last_event_id: Annotated[
-        Optional[str],
+        str | None,
         Field(None, description="ID of the last event that modified this account"),
     ]
     # Total statistics fields
@@ -315,7 +318,7 @@ class CreditAccount(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
 
@@ -347,7 +350,11 @@ class CreditAccount(BaseModel):
         )
         result = await session.scalar(stmt)
         if not result:
-            raise HTTPException(status_code=404, detail="Credit account not found")
+            raise IntentKitAPIError(
+                status_code=404,
+                key="CreditAccountNotFound",
+                message="Credit account not found",
+            )
         return cls.model_validate(result)
 
     @classmethod
@@ -408,7 +415,7 @@ class CreditAccount(BaseModel):
         owner_id: str,
         credit_type: CreditType,
         amount: Decimal,
-        event_id: Optional[str] = None,
+        event_id: str | None = None,
     ) -> "CreditAccount":
         """Deduct credits from an account. Not checking balance"""
         # check first, create if not exists
@@ -419,7 +426,7 @@ class CreditAccount(BaseModel):
         values_dict = {
             credit_type.value: getattr(CreditAccountTable, credit_type.value)
             - quantized_amount,
-            "expense_at": datetime.now(timezone.utc),
+            "expense_at": datetime.now(UTC),
             # Update total expense statistics
             "total_expense": CreditAccountTable.total_expense + quantized_amount,
         }
@@ -451,7 +458,11 @@ class CreditAccount(BaseModel):
         )
         res = await session.scalar(stmt)
         if not res:
-            raise HTTPException(status_code=500, detail="Failed to expense credits")
+            raise IntentKitAPIError(
+                status_code=500,
+                key="CreditExpenseFailed",
+                message="Failed to expense credits",
+            )
         return cls.model_validate(res)
 
     @classmethod
@@ -461,8 +472,8 @@ class CreditAccount(BaseModel):
         owner_type: OwnerType,
         owner_id: str,
         amount: Decimal,
-        event_id: Optional[str] = None,
-    ) -> Tuple["CreditAccount", Dict[CreditType, Decimal]]:
+        event_id: str | None = None,
+    ) -> tuple["CreditAccount", dict[CreditType, Decimal]]:
         """Expense credits and return account and credit type.
         We are not checking balance here, since a conversation may have
         multiple expenses, we can't interrupt the conversation.
@@ -497,7 +508,7 @@ class CreditAccount(BaseModel):
 
         # Create values dict based on what's in details, defaulting to 0 for missing keys
         values_dict = {
-            "expense_at": datetime.now(timezone.utc),
+            "expense_at": datetime.now(UTC),
         }
         if event_id:
             values_dict["last_event_id"] = event_id
@@ -548,7 +559,11 @@ class CreditAccount(BaseModel):
         )
         res = await session.scalar(stmt)
         if not res:
-            raise HTTPException(status_code=500, detail="Failed to expense credits")
+            raise IntentKitAPIError(
+                status_code=500,
+                key="CreditExpenseFailed",
+                message="Failed to expense credits",
+            )
         return cls.model_validate(res), details
 
     def has_sufficient_credits(self, amount: Decimal) -> bool:
@@ -568,14 +583,14 @@ class CreditAccount(BaseModel):
         session: AsyncSession,
         owner_type: OwnerType,
         owner_id: str,
-        amount_details: Dict[CreditType, Decimal],
-        event_id: Optional[str] = None,
+        amount_details: dict[CreditType, Decimal],
+        event_id: str | None = None,
     ) -> "CreditAccount":
         # check first, create if not exists
         await cls.get_or_create_in_session(session, owner_type, owner_id)
         # income
         values_dict = {
-            "income_at": datetime.now(timezone.utc),
+            "income_at": datetime.now(UTC),
         }
         if event_id:
             values_dict["last_event_id"] = event_id
@@ -633,8 +648,8 @@ class CreditAccount(BaseModel):
         session: AsyncSession,
         owner_type: OwnerType,
         owner_id: str,
-        free_quota: Optional[Decimal] = None,
-        refill_amount: Optional[Decimal] = None,
+        free_quota: Decimal | None = None,
+        refill_amount: Decimal | None = None,
     ) -> "CreditAccount":
         """Get an existing credit account or create a new one if it doesn't exist.
 
@@ -674,7 +689,7 @@ class CreditAccount(BaseModel):
             free_credits=free_quota,
             reward_credits=0.0,
             credits=0.0,
-            income_at=datetime.now(timezone.utc),
+            income_at=datetime.now(UTC),
             expense_at=None,
             last_event_id=event_id if owner_type == OwnerType.USER else None,
             # Initialize new statistics fields
@@ -768,8 +783,8 @@ class CreditAccount(BaseModel):
         cls,
         session: AsyncSession,
         user_id: str,
-        free_quota: Optional[Decimal] = None,
-        refill_amount: Optional[Decimal] = None,
+        free_quota: Decimal | None = None,
+        refill_amount: Decimal | None = None,
         upstream_tx_id: str = "",
         note: str = "",
     ) -> "CreditAccount":
@@ -912,199 +927,203 @@ class CreditEventTable(Base):
         Index("ix_credit_events_created_at", "created_at"),
     )
 
-    id = Column(
+    id: Mapped[str] = mapped_column(
         String,
         primary_key=True,
     )
-    account_id = Column(
+    account_id: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    event_type = Column(
+    event_type: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    user_id = Column(
+    user_id: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
-    upstream_type = Column(
+    team_id: Mapped[str | None] = mapped_column(
+        String,
+        nullable=True,
+    )
+    upstream_type: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    upstream_tx_id = Column(
+    upstream_tx_id: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    agent_id = Column(
+    agent_id: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
-    agent_wallet_address = Column(
+    agent_wallet_address: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
-    start_message_id = Column(
+    start_message_id: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
-    message_id = Column(
+    message_id: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
-    model = Column(
+    model: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
-    skill_call_id = Column(
+    skill_call_id: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
-    skill_name = Column(
+    skill_name: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
-    direction = Column(
+    direction: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    total_amount = Column(
+    total_amount: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    credit_type = Column(
+    credit_type: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    credit_types = Column(
+    credit_types: Mapped[list[str] | None] = mapped_column(
         JSON().with_variant(ARRAY(String), "postgresql"),
         nullable=True,
     )
-    balance_after = Column(
+    balance_after: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         nullable=True,
         default=None,
     )
-    base_amount = Column(
+    base_amount: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    base_discount_amount = Column(
+    base_discount_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    base_original_amount = Column(
+    base_original_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    base_llm_amount = Column(
+    base_llm_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    base_skill_amount = Column(
+    base_skill_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    base_free_amount = Column(
+    base_free_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    base_reward_amount = Column(
+    base_reward_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    base_permanent_amount = Column(
+    base_permanent_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    fee_platform_amount = Column(
+    fee_platform_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    fee_platform_free_amount = Column(
+    fee_platform_free_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         nullable=True,
     )
-    fee_platform_reward_amount = Column(
+    fee_platform_reward_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         nullable=True,
     )
-    fee_platform_permanent_amount = Column(
+    fee_platform_permanent_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         nullable=True,
     )
-    fee_dev_account = Column(
+    fee_dev_account: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
-    fee_dev_amount = Column(
+    fee_dev_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    fee_dev_free_amount = Column(
+    fee_dev_free_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         nullable=True,
     )
-    fee_dev_reward_amount = Column(
+    fee_dev_reward_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         nullable=True,
     )
-    fee_dev_permanent_amount = Column(
+    fee_dev_permanent_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         nullable=True,
     )
-    fee_agent_account = Column(
+    fee_agent_account: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
-    fee_agent_amount = Column(
+    fee_agent_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    fee_agent_free_amount = Column(
+    fee_agent_free_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         nullable=True,
     )
-    fee_agent_reward_amount = Column(
+    fee_agent_reward_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         nullable=True,
     )
-    fee_agent_permanent_amount = Column(
+    fee_agent_permanent_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         nullable=True,
     )
-    free_amount = Column(
+    free_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    reward_amount = Column(
+    reward_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    permanent_amount = Column(
+    permanent_amount: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=True,
     )
-    note = Column(
+    note: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
-    created_at = Column(
+    created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
@@ -1134,34 +1153,37 @@ class CreditEvent(BaseModel):
     ]
     event_type: Annotated[EventType, Field(description="Type of the event")]
     user_id: Annotated[
-        Optional[str], Field(None, description="ID of the user if applicable")
+        str | None, Field(None, description="ID of the user if applicable")
+    ]
+    team_id: Annotated[
+        str | None, Field(None, description="ID of the team if applicable")
     ]
     upstream_type: Annotated[
         UpstreamType, Field(description="Type of upstream transaction")
     ]
     upstream_tx_id: Annotated[str, Field(description="Upstream transaction ID if any")]
     agent_id: Annotated[
-        Optional[str], Field(None, description="ID of the agent if applicable")
+        str | None, Field(None, description="ID of the agent if applicable")
     ]
     agent_wallet_address: Annotated[
-        Optional[str],
+        str | None,
         Field(None, description="Wallet address of the agent if applicable"),
     ]
     start_message_id: Annotated[
-        Optional[str],
+        str | None,
         Field(None, description="ID of the starting message if applicable"),
     ]
     message_id: Annotated[
-        Optional[str], Field(None, description="ID of the message if applicable")
+        str | None, Field(None, description="ID of the message if applicable")
     ]
     model: Annotated[
-        Optional[str], Field(None, description="LLM model used if applicable")
+        str | None, Field(None, description="LLM model used if applicable")
     ]
     skill_call_id: Annotated[
-        Optional[str], Field(None, description="ID of the skill call if applicable")
+        str | None, Field(None, description="ID of the skill call if applicable")
     ]
     skill_name: Annotated[
-        Optional[str], Field(None, description="Name of the skill if applicable")
+        str | None, Field(None, description="Name of the skill if applicable")
     ]
     direction: Annotated[Direction, Field(description="Direction of the credit flow")]
     total_amount: Annotated[
@@ -1173,11 +1195,11 @@ class CreditEvent(BaseModel):
     ]
     credit_type: Annotated[CreditType, Field(description="Type of credits involved")]
     credit_types: Annotated[
-        Optional[List[CreditType]],
+        list[CreditType] | None,
         Field(default=None, description="Array of credit types involved"),
     ]
     balance_after: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(None, description="Account total balance after the transaction"),
     ]
     base_amount: Annotated[
@@ -1185,115 +1207,115 @@ class CreditEvent(BaseModel):
         Field(default=Decimal("0"), description="Base amount of credits involved"),
     ]
     base_discount_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Base discount amount"),
     ]
     base_original_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Base original amount"),
     ]
     base_llm_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Base LLM cost amount"),
     ]
     base_skill_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Base skill cost amount"),
     ]
     base_free_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Base free credit amount"),
     ]
     base_reward_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Base reward credit amount"),
     ]
     base_permanent_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Base permanent credit amount"),
     ]
     fee_platform_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Platform fee amount"),
     ]
     fee_platform_free_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(
             default=Decimal("0"), description="Platform fee amount from free credits"
         ),
     ]
     fee_platform_reward_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(
             default=Decimal("0"), description="Platform fee amount from reward credits"
         ),
     ]
     fee_platform_permanent_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(
             default=Decimal("0"),
             description="Platform fee amount from permanent credits",
         ),
     ]
     fee_dev_account: Annotated[
-        Optional[str], Field(None, description="Developer account ID receiving fee")
+        str | None, Field(None, description="Developer account ID receiving fee")
     ]
     fee_dev_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Developer fee amount"),
     ]
     fee_dev_free_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(
             default=Decimal("0"), description="Developer fee amount from free credits"
         ),
     ]
     fee_dev_reward_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(
             default=Decimal("0"), description="Developer fee amount from reward credits"
         ),
     ]
     fee_dev_permanent_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(
             default=Decimal("0"),
             description="Developer fee amount from permanent credits",
         ),
     ]
     fee_agent_account: Annotated[
-        Optional[str], Field(None, description="Agent account ID receiving fee")
+        str | None, Field(None, description="Agent account ID receiving fee")
     ]
     fee_agent_amount: Annotated[
-        Optional[Decimal], Field(default=Decimal("0"), description="Agent fee amount")
+        Decimal | None, Field(default=Decimal("0"), description="Agent fee amount")
     ]
     fee_agent_free_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Agent fee amount from free credits"),
     ]
     fee_agent_reward_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Agent fee amount from reward credits"),
     ]
     fee_agent_permanent_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(
             default=Decimal("0"), description="Agent fee amount from permanent credits"
         ),
     ]
     free_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Free credit amount involved"),
     ]
     reward_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Reward credit amount involved"),
     ]
     permanent_amount: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         Field(default=Decimal("0"), description="Permanent credit amount involved"),
     ]
-    note: Annotated[Optional[str], Field(None, description="Additional notes")]
+    note: Annotated[str | None, Field(None, description="Additional notes")]
     created_at: Annotated[
         datetime, Field(description="Timestamp when this event was created")
     ]
@@ -1326,13 +1348,13 @@ class CreditEvent(BaseModel):
         "permanent_amount",
     )
     @classmethod
-    def round_decimal(cls, v: Any) -> Optional[Decimal]:
+    def round_decimal(cls, v: Any) -> Decimal | None:
         """Round decimal values to 4 decimal places."""
         if v is None:
             return None
         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
 
@@ -1406,51 +1428,51 @@ class CreditTransactionTable(Base):
         Index("ix_credit_transactions_event_id", "event_id"),
     )
 
-    id = Column(
+    id: Mapped[str] = mapped_column(
         String,
         primary_key=True,
     )
-    account_id = Column(
+    account_id: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    event_id = Column(
+    event_id: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    tx_type = Column(
+    tx_type: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    credit_debit = Column(
+    credit_debit: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    change_amount = Column(
+    change_amount: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    free_amount = Column(
+    free_amount: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    reward_amount = Column(
+    reward_amount: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    permanent_amount = Column(
+    permanent_amount: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    credit_type = Column(
+    credit_type: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    created_at = Column(
+    created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
@@ -1507,7 +1529,7 @@ class CreditTransaction(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
 
@@ -1542,37 +1564,37 @@ class CreditPriceTable(Base):
 
     __tablename__ = "credit_prices"
 
-    id = Column(
+    id: Mapped[str] = mapped_column(
         String,
         primary_key=True,
     )
-    price_entity = Column(
+    price_entity: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    price_entity_id = Column(
+    price_entity_id: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    discount_type = Column(
+    discount_type: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    price = Column(
+    price: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         default=0,
         nullable=False,
     )
-    created_at = Column(
+    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),
     )
 
 
@@ -1610,7 +1632,7 @@ class CreditPrice(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
 
@@ -1630,31 +1652,31 @@ class CreditPriceLogTable(Base):
 
     __tablename__ = "credit_price_logs"
 
-    id = Column(
+    id: Mapped[str] = mapped_column(
         String,
         primary_key=True,
     )
-    price_id = Column(
+    price_id: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    old_price = Column(
+    old_price: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         nullable=False,
     )
-    new_price = Column(
+    new_price: Mapped[Decimal] = mapped_column(
         Numeric(22, 4),
         nullable=False,
     )
-    note = Column(
+    note: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
     )
-    modified_by = Column(
+    modified_by: Mapped[str] = mapped_column(
         String,
         nullable=False,
     )
-    modified_at = Column(
+    modified_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
@@ -1687,13 +1709,11 @@ class CreditPriceLog(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
 
-    note: Annotated[
-        Optional[str], Field(None, description="Note about the modification")
-    ]
+    note: Annotated[str | None, Field(None, description="Note about the modification")]
     modified_by: Annotated[
         str, Field(description="ID of the user who made the modification")
     ]