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

intentkit/models/agent.py

@@ -1,12 +1,14 @@
+from __future__ import annotations
+
 import hashlib
 import json
 import logging
 import re
 import textwrap
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from decimal import Decimal
 from pathlib import Path
-from typing import Annotated, Any, Dict, List, Literal, Optional
+from typing import Annotated, Any, Literal
 
 import jsonref
 import yaml
@@ -57,7 +59,7 @@ class AgentAutonomous(BaseModel):
         ),
     ]
     name: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Display name of the autonomous configuration",
@@ -68,7 +70,7 @@ class AgentAutonomous(BaseModel):
         ),
     ]
     description: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Description of the autonomous configuration",
@@ -79,7 +81,7 @@ class AgentAutonomous(BaseModel):
         ),
     ]
     minutes: Annotated[
-        Optional[int],
+        int | None,
         PydanticField(
             default=None,
             description="Interval in minutes between operations, mutually exclusive with cron",
@@ -89,7 +91,7 @@ class AgentAutonomous(BaseModel):
         ),
     ]
     cron: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Cron expression for scheduling operations, mutually exclusive with minutes",
@@ -109,7 +111,7 @@ class AgentAutonomous(BaseModel):
         ),
     ]
     enabled: Annotated[
-        Optional[bool],
+        bool | None,
         PydanticField(
             default=False,
             description="Whether the autonomous configuration is enabled",
@@ -289,6 +291,17 @@ class AgentUserInputColumns:
         nullable=True,
         comment="Telegram integration configuration settings",
     )
+    discord_entrypoint_enabled = Column(
+        Boolean,
+        nullable=True,
+        default=False,
+        comment="Whether the agent can receive events from Discord",
+    )
+    discord_config = Column(
+        JSON().with_variant(JSONB(), "postgresql"),
+        nullable=True,
+        comment="Discord integration configuration settings",
+    )
     xmtp_entrypoint_prompt = Column(
         String,
         nullable=True,
@@ -421,7 +434,7 @@ class AgentTable(Base, AgentUserInputColumns):
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
-        onupdate=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(UTC),
         comment="Timestamp when the agent was last updated",
     )
 
@@ -430,75 +443,43 @@ class AgentCore(BaseModel):
     """Agent core model."""
 
     name: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             title="Name",
             description="Display name of the agent",
             max_length=50,
-            json_schema_extra={
-                "x-group": "basic",
-                "x-placeholder": "Name your agent",
-            },
         ),
     ]
     picture: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
-            description="Picture of the agent",
-            json_schema_extra={
-                "x-group": "experimental",
-                "x-placeholder": "Upload a picture of your agent",
-            },
+            description="Avatar of the agent",
         ),
     ]
     purpose: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Purpose or role of the agent",
             max_length=20000,
-            json_schema_extra={
-                "x-group": "basic",
-                "x-placeholder": "Enter agent purpose, it will be a part of the system prompt",
-                "pattern": "^(([^#].*)|#[^# ].*|#{3,}[ ].*|$)(\n(([^#].*)|#[^# ].*|#{3,}[ ].*|$))*$",
-                "errorMessage": {
-                    "pattern": "Level 1 and 2 headings (# and ##) are not allowed. Please use level 3+ headings (###, ####, etc.) instead."
-                },
-            },
         ),
     ]
     personality: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Personality traits of the agent",
             max_length=20000,
-            json_schema_extra={
-                "x-group": "basic",
-                "x-placeholder": "Enter agent personality, it will be a part of the system prompt",
-                "pattern": "^(([^#].*)|#[^# ].*|#{3,}[ ].*|$)(\n(([^#].*)|#[^# ].*|#{3,}[ ].*|$))*$",
-                "errorMessage": {
-                    "pattern": "Level 1 and 2 headings (# and ##) are not allowed. Please use level 3+ headings (###, ####, etc.) instead."
-                },
-            },
         ),
     ]
     principles: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Principles or values of the agent",
             max_length=20000,
-            json_schema_extra={
-                "x-group": "basic",
-                "x-placeholder": "Enter agent principles, it will be a part of the system prompt",
-                "pattern": "^(([^#].*)|#[^# ].*|#{3,}[ ].*|$)(\n(([^#].*)|#[^# ].*|#{3,}[ ].*|$))*$",
-                "errorMessage": {
-                    "pattern": "Level 1 and 2 headings (# and ##) are not allowed. Please use level 3+ headings (###, ####, etc.) instead."
-                },
-            },
         ),
     ]
     # AI part
@@ -506,128 +487,86 @@ class AgentCore(BaseModel):
         str,
         PydanticField(
             default="gpt-5-mini",
-            description="AI model identifier to be used by this agent for processing requests.",
-            json_schema_extra={
-                "x-group": "ai",
-            },
+            description="LLM of the agent",
         ),
     ]
     prompt: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Base system prompt that defines the agent's behavior and capabilities",
             max_length=20000,
-            json_schema_extra={
-                "x-group": "ai",
-                "pattern": "^(([^#].*)|#[^# ].*|#{3,}[ ].*|$)(\n(([^#].*)|#[^# ].*|#{3,}[ ].*|$))*$",
-                "errorMessage": {
-                    "pattern": "Level 1 and 2 headings (# and ##) are not allowed. Please use level 3+ headings (###, ####, etc.) instead."
-                },
-            },
         ),
     ]
     prompt_append: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Additional system prompt that has higher priority than the base prompt",
             max_length=20000,
-            json_schema_extra={
-                "x-group": "ai",
-                "pattern": "^(([^#].*)|#[^# ].*|#{3,}[ ].*|$)(\n(([^#].*)|#[^# ].*|#{3,}[ ].*|$))*$",
-                "errorMessage": {
-                    "pattern": "Level 1 and 2 headings (# and ##) are not allowed. Please use level 3+ headings (###, ####, etc.) instead."
-                },
-            },
         ),
     ]
     temperature: Annotated[
-        Optional[float],
+        float | None,
         PydanticField(
             default=0.7,
             description="The randomness of the generated results is such that the higher the number, the more creative the results will be. However, this also makes them wilder and increases the likelihood of errors. For creative tasks, you can adjust it to above 1, but for rigorous tasks, such as quantitative trading, it's advisable to set it lower, around 0.2. (0.0~2.0)",
             ge=0.0,
             le=2.0,
-            json_schema_extra={
-                "x-group": "ai",
-            },
         ),
     ]
     frequency_penalty: Annotated[
-        Optional[float],
+        float | None,
         PydanticField(
             default=0.0,
             description="The frequency penalty is a measure of how much the AI is allowed to repeat itself. A lower value means the AI is more likely to repeat previous responses, while a higher value means the AI is more likely to generate new content. For creative tasks, you can adjust it to 1 or a bit higher. (-2.0~2.0)",
             ge=-2.0,
             le=2.0,
-            json_schema_extra={
-                "x-group": "ai",
-            },
         ),
     ]
     presence_penalty: Annotated[
-        Optional[float],
+        float | None,
         PydanticField(
             default=0.0,
             description="The presence penalty is a measure of how much the AI is allowed to deviate from the topic. A higher value means the AI is more likely to deviate from the topic, while a lower value means the AI is more likely to follow the topic. For creative tasks, you can adjust it to 1 or a bit higher. (-2.0~2.0)",
             ge=-2.0,
             le=2.0,
-            json_schema_extra={
-                "x-group": "ai",
-            },
         ),
     ]
     wallet_provider: Annotated[
-        Optional[Literal["cdp", "readonly", "none"]],
+        Literal["cdp", "readonly", "none"] | None,
         PydanticField(
             default=None,
             description="Provider of the agent's wallet",
-            json_schema_extra={
-                "x-group": "onchain",
-            },
         ),
     ]
     readonly_wallet_address: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Address of the agent's wallet, only used when wallet_provider is readonly. Agent will not be able to sign transactions.",
         ),
     ]
     network_id: Annotated[
-        Optional[
-            Literal[
-                "base-mainnet",
-                "base-sepolia",
-                "ethereum-mainnet",
-                "ethereum-sepolia",
-                "polygon-mainnet",
-                "polygon-mumbai",
-                "arbitrum-mainnet",
-                "arbitrum-sepolia",
-                "optimism-mainnet",
-                "optimism-sepolia",
-                "solana",
-            ]
-        ],
+        Literal[
+            "base-mainnet",
+            "ethereum-mainnet",
+            "polygon-mainnet",
+            "arbitrum-mainnet",
+            "optimism-mainnet",
+            "solana",
+        ]
+        | None,
         PydanticField(
             default="base-mainnet",
             description="Network identifier",
-            json_schema_extra={
-                "x-group": "onchain",
-            },
         ),
     ]
     skills: Annotated[
-        Optional[Dict[str, Any]],
+        dict[str, Any] | None,
         PydanticField(
             default=None,
             description="Dict of skills and their corresponding configurations",
-            json_schema_extra={
-                "x-group": "skills",
-                "x-inline": True,
-            },
         ),
     ]
 
@@ -670,18 +609,15 @@ class AgentUserInput(AgentCore):
     )
 
     short_term_memory_strategy: Annotated[
-        Optional[Literal["trim", "summarize"]],
+        Literal["trim", "summarize"] | None,
         PydanticField(
             default="trim",
             description="Strategy for managing short-term memory when context limit is reached. 'trim' removes oldest messages, 'summarize' creates summaries.",
-            json_schema_extra={
-                "x-group": "ai",
-            },
         ),
     ]
     # autonomous mode
     autonomous: Annotated[
-        Optional[List[AgentAutonomous]],
+        list[AgentAutonomous] | None,
         PydanticField(
             default=None,
             description=(
@@ -698,53 +634,57 @@ class AgentUserInput(AgentCore):
                 "    prompt: |-\n"
                 "      Say hi [sequence], use number for sequence.\n"
             ),
-            json_schema_extra={
-                "x-group": "autonomous",
-                "x-inline": True,
-            },
         ),
     ]
     # if telegram_entrypoint_enabled, the telegram_entrypoint_enabled will be enabled, telegram_config will be checked
     telegram_entrypoint_enabled: Annotated[
-        Optional[bool],
+        bool | None,
         PydanticField(
             default=False,
             description="Whether the agent can play telegram bot",
-            json_schema_extra={
-                "x-group": "entrypoint",
-            },
         ),
     ]
     telegram_entrypoint_prompt: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Extra prompt for telegram entrypoint",
             max_length=10000,
+        ),
+    ]
+    telegram_config: Annotated[
+        dict | None,
+        PydanticField(
+            default=None,
+            description="Telegram integration configuration settings",
+        ),
+    ]
+    discord_entrypoint_enabled: Annotated[
+        bool | None,
+        PydanticField(
+            default=False,
+            description="Whether the agent can play discord bot",
             json_schema_extra={
                 "x-group": "entrypoint",
             },
         ),
     ]
-    telegram_config: Annotated[
-        Optional[dict],
+    discord_config: Annotated[
+        dict | None,
         PydanticField(
             default=None,
-            description="Telegram integration configuration settings",
+            description="Discord integration configuration settings including token, whitelists, and behavior settings",
             json_schema_extra={
                 "x-group": "entrypoint",
             },
         ),
     ]
     xmtp_entrypoint_prompt: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Extra prompt for xmtp entrypoint, xmtp support is in beta",
             max_length=10000,
-            json_schema_extra={
-                "x-group": "entrypoint",
-            },
         ),
     ]
 
@@ -761,7 +701,7 @@ class AgentUpdate(AgentUserInput):
     )
 
     upstream_id: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="External reference ID for idempotent operations",
@@ -769,7 +709,7 @@ class AgentUpdate(AgentUserInput):
         ),
     ]
     upstream_extra: Annotated[
-        Optional[Dict[str, Any]],
+        dict[str, Any] | None,
         PydanticField(
             default=None,
             description="Additional data store for upstream use",
@@ -781,7 +721,7 @@ class AgentUpdate(AgentUserInput):
 
     @field_validator("purpose", "personality", "principles", "prompt", "prompt_append")
     @classmethod
-    def validate_no_level1_level2_headings(cls, v: Optional[str]) -> Optional[str]:
+    def validate_no_level1_level2_headings(cls, v: str | None) -> str | None:
         """Validate that the text doesn't contain level 1 or level 2 headings."""
         if v is None:
             return v
@@ -940,7 +880,7 @@ class AgentCreate(AgentUpdate):
         ),
     ]
     owner: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Owner identifier of the agent, used for access control",
@@ -962,7 +902,7 @@ class AgentCreate(AgentUpdate):
                     message="Upstream id already in use",
                 )
 
-    async def get_by_upstream_id(self) -> Optional["Agent"]:
+    async def get_by_upstream_id(self) -> Agent | None:
         if not self.upstream_id:
             return None
         async with get_session() as db:
@@ -1005,7 +945,7 @@ class AgentPublicInfo(BaseModel):
     )
 
     description: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Description of the agent, for public view, not contained in prompt",
@@ -1015,7 +955,7 @@ class AgentPublicInfo(BaseModel):
         ),
     ]
     external_website: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Link of external website of the agent, if you have one",
@@ -1026,7 +966,7 @@ class AgentPublicInfo(BaseModel):
         ),
     ]
     ticker: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Ticker symbol of the agent",
@@ -1038,7 +978,7 @@ class AgentPublicInfo(BaseModel):
         ),
     ]
     token_address: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Token address of the agent",
@@ -1049,7 +989,7 @@ class AgentPublicInfo(BaseModel):
         ),
     ]
     token_pool: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Pool of the agent token",
@@ -1060,7 +1000,7 @@ class AgentPublicInfo(BaseModel):
         ),
     ]
     fee_percentage: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         PydanticField(
             default=None,
             description="Fee percentage of the agent",
@@ -1071,7 +1011,7 @@ class AgentPublicInfo(BaseModel):
         ),
     ]
     example_intro: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Introduction of the example",
@@ -1082,7 +1022,7 @@ class AgentPublicInfo(BaseModel):
         ),
     ]
     examples: Annotated[
-        Optional[List[AgentExample]],
+        list[AgentExample] | None,
         PydanticField(
             default=None,
             description="List of example prompts for the agent",
@@ -1093,7 +1033,7 @@ class AgentPublicInfo(BaseModel):
         ),
     ]
     public_extra: Annotated[
-        Optional[Dict[str, Any]],
+        dict[str, Any] | None,
         PydanticField(
             default=None,
             description="Public extra data of the agent",
@@ -1141,7 +1081,7 @@ class Agent(AgentCreate, AgentPublicInfo):
     model_config = ConfigDict(from_attributes=True)
 
     slug: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Slug of the agent, used for URL generation",
@@ -1150,49 +1090,49 @@ class Agent(AgentCreate, AgentPublicInfo):
         ),
     ]
     version: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Version hash of the agent",
         ),
     ]
     statistics: Annotated[
-        Optional[Dict[str, Any]],
+        dict[str, Any] | None,
         PydanticField(
             default=None,
             description="Statistics of the agent, update every 1 hour for query",
         ),
     ]
     assets: Annotated[
-        Optional[Dict[str, Any]],
+        dict[str, Any] | None,
         PydanticField(
             default=None,
             description="Assets of the agent, update every 1 hour for query",
         ),
     ]
     account_snapshot: Annotated[
-        Optional[CreditAccount],
+        CreditAccount | None,
         PydanticField(
             default=None,
             description="Account snapshot of the agent, update every 1 hour for query",
         ),
     ]
     extra: Annotated[
-        Optional[Dict[str, Any]],
+        dict[str, Any] | None,
         PydanticField(
             default=None,
             description="Other helper data fields for query, come from agent and agent data",
         ),
     ]
     deployed_at: Annotated[
-        Optional[datetime],
+        datetime | None,
         PydanticField(
             default=None,
             description="Timestamp when the agent was deployed",
         ),
     ]
     public_info_updated_at: Annotated[
-        Optional[datetime],
+        datetime | None,
         PydanticField(
             default=None,
             description="Timestamp when the agent public info was last updated",
@@ -1233,8 +1173,11 @@ class Agent(AgentCreate, AgentPublicInfo):
         return False
 
     async def is_model_support_image(self) -> bool:
-        model = await LLMModelInfo.get(self.model)
-        return model.supports_image_input
+        try:
+            model = await LLMModelInfo.get(self.model)
+            return model.supports_image_input
+        except Exception:
+            return False
 
     def to_yaml(self) -> str:
         """
@@ -1327,7 +1270,7 @@ class Agent(AgentCreate, AgentPublicInfo):
                     )
                     yaml_lines.append(yaml_value.rstrip())
             elif isinstance(value, list) and value and hasattr(value[0], "model_dump"):
-                # Handle list of Pydantic models (e.g., List[AgentAutonomous])
+                # Handle list of Pydantic models (e.g., list[AgentAutonomous])
                 yaml_lines.append(f"{field_name}:")
                 # Convert each Pydantic model to dict
                 model_dicts = [item.model_dump(exclude_none=True) for item in value]
@@ -1373,18 +1316,154 @@ class Agent(AgentCreate, AgentPublicInfo):
             return await db.scalar(select(func.count(AgentTable.id)))
 
     @classmethod
-    async def get(cls, agent_id: str) -> Optional["Agent"]:
+    async def get(cls, agent_id: str) -> "Agent" | None:
         async with get_session() as db:
             item = await db.scalar(select(AgentTable).where(AgentTable.id == agent_id))
             if item is None:
                 return None
             return cls.model_validate(item)
 
-    def skill_config(self, category: str) -> Dict[str, Any]:
+    @classmethod
+    async def get_by_id_or_slug(cls, agent_id: str) -> "Agent" | None:
+        """Get agent by ID or slug.
+
+        First tries to get by ID if agent_id length <= 20,
+        then falls back to searching by slug if not found.
+
+        Args:
+            agent_id: Agent ID or slug to search for
+
+        Returns:
+            Agent if found, None otherwise
+        """
+        async with get_session() as db:
+            agent = None
+
+            # Try to get by ID if length <= 20
+            if len(agent_id) <= 20:
+                agent = await Agent.get(agent_id)
+
+            # If not found, try to get by slug
+            if agent is None:
+                slug_stmt = select(AgentTable).where(AgentTable.slug == agent_id)
+                agent_row = await db.scalar(slug_stmt)
+                if agent_row is not None:
+                    agent = Agent.model_validate(agent_row)
+
+            return agent
+
+    @staticmethod
+    def _deserialize_autonomous(
+        autonomous_data: list[Any] | None,
+    ) -> list[AgentAutonomous]:
+        if not autonomous_data:
+            return []
+
+        deserialized: list[AgentAutonomous] = []
+        for entry in autonomous_data:
+            if isinstance(entry, AgentAutonomous):
+                deserialized.append(entry)
+            else:
+                deserialized.append(AgentAutonomous.model_validate(entry))
+        return deserialized
+
+    @staticmethod
+    def _serialize_autonomous(tasks: list[AgentAutonomous]) -> list[dict[str, Any]]:
+        return [task.model_dump() for task in tasks]
+
+    @staticmethod
+    def _autonomous_not_allowed_error() -> IntentKitAPIError:
+        return IntentKitAPIError(
+            400,
+            "AgentNotDeployed",
+            "Only deployed agents can call this feature.",
+        )
+
+    async def list_autonomous_tasks(self) -> list[AgentAutonomous]:
+        persisted = await Agent.get(self.id)
+        if persisted is None:
+            raise self._autonomous_not_allowed_error()
+
+        tasks = persisted.autonomous or []
+        # Keep local state in sync with persisted data
+        self.autonomous = tasks
+        return tasks
+
+    async def add_autonomous_task(self, task: AgentAutonomous) -> AgentAutonomous:
+        async with get_session() as session:
+            db_agent = await session.get(AgentTable, self.id)
+            if db_agent is None:
+                raise self._autonomous_not_allowed_error()
+
+            current_tasks = self._deserialize_autonomous(db_agent.autonomous)
+            current_tasks.append(task)
+
+            db_agent.autonomous = self._serialize_autonomous(current_tasks)
+            await session.commit()
+
+        self.autonomous = current_tasks
+        return task
+
+    async def delete_autonomous_task(self, task_id: str) -> None:
+        async with get_session() as session:
+            db_agent = await session.get(AgentTable, self.id)
+            if db_agent is None:
+                raise self._autonomous_not_allowed_error()
+
+            current_tasks = self._deserialize_autonomous(db_agent.autonomous)
+
+            updated_tasks = [task for task in current_tasks if task.id != task_id]
+            if len(updated_tasks) == len(current_tasks):
+                raise IntentKitAPIError(
+                    404,
+                    "TaskNotFound",
+                    f"Autonomous task with ID {task_id} not found.",
+                )
+
+            db_agent.autonomous = self._serialize_autonomous(updated_tasks)
+            await session.commit()
+
+        self.autonomous = updated_tasks
+
+    async def update_autonomous_task(
+        self, task_id: str, task_updates: dict
+    ) -> AgentAutonomous:
+        async with get_session() as session:
+            db_agent = await session.get(AgentTable, self.id)
+            if db_agent is None:
+                raise self._autonomous_not_allowed_error()
+
+            current_tasks = self._deserialize_autonomous(db_agent.autonomous)
+
+            updated_task: AgentAutonomous | None = None
+            rewritten_tasks: list[AgentAutonomous] = []
+            for task in current_tasks:
+                if task.id == task_id:
+                    task_dict = task.model_dump()
+                    task_dict.update(task_updates)
+                    updated_task = AgentAutonomous.model_validate(task_dict)
+                    rewritten_tasks.append(updated_task)
+                else:
+                    rewritten_tasks.append(task)
+
+            if updated_task is None:
+                raise IntentKitAPIError(
+                    404,
+                    "TaskNotFound",
+                    f"Autonomous task with ID {task_id} not found.",
+                )
+
+            db_agent.autonomous = self._serialize_autonomous(rewritten_tasks)
+            await session.commit()
+
+        self.autonomous = rewritten_tasks
+        return updated_task
+
+    def skill_config(self, category: str) -> dict[str, Any]:
         return self.skills.get(category, {}) if self.skills else {}
 
     @staticmethod
-    def _is_agent_owner_only_skill(skill_schema: Dict[str, Any]) -> bool:
+    def _is_agent_owner_only_skill(skill_schema: dict[str, Any]) -> bool:
         """Check if a skill requires agent owner API keys only based on its resolved schema."""
         if (
             skill_schema
@@ -1403,7 +1482,7 @@ class Agent(AgentCreate, AgentPublicInfo):
         cls,
         db: AsyncSession = None,
         filter_owner_api_skills: bool = False,
-    ) -> Dict:
+    ) -> dict:
         """Get the JSON schema for Agent model with all $ref references resolved.
 
         This is the shared function that handles admin configuration filtering
@@ -1591,34 +1670,35 @@ class AgentResponse(Agent):
     )
 
     # Override privacy fields to exclude them from JSON schema
-    purpose: SkipJsonSchema[Optional[str]] = None
-    personality: SkipJsonSchema[Optional[str]] = None
-    principles: SkipJsonSchema[Optional[str]] = None
-    prompt: SkipJsonSchema[Optional[str]] = None
-    prompt_append: SkipJsonSchema[Optional[str]] = None
-    temperature: SkipJsonSchema[Optional[float]] = None
-    frequency_penalty: SkipJsonSchema[Optional[float]] = None
-    telegram_entrypoint_prompt: SkipJsonSchema[Optional[str]] = None
-    telegram_config: SkipJsonSchema[Optional[dict]] = None
-    xmtp_entrypoint_prompt: SkipJsonSchema[Optional[str]] = None
+    purpose: SkipJsonSchema[str | None] = None
+    personality: SkipJsonSchema[str | None] = None
+    principles: SkipJsonSchema[str | None] = None
+    prompt: SkipJsonSchema[str | None] = None
+    prompt_append: SkipJsonSchema[str | None] = None
+    temperature: SkipJsonSchema[float | None] = None
+    frequency_penalty: SkipJsonSchema[float | None] = None
+    telegram_entrypoint_prompt: SkipJsonSchema[str | None] = None
+    telegram_config: SkipJsonSchema[dict | None] = None
+    discord_config: SkipJsonSchema[dict | None] = None
+    xmtp_entrypoint_prompt: SkipJsonSchema[str | None] = None
 
     # Additional fields specific to AgentResponse
     cdp_wallet_address: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="CDP wallet address of the agent",
         ),
     ]
     evm_wallet_address: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="EVM wallet address of the agent",
         ),
     ]
     solana_wallet_address: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Solana wallet address of the agent",
@@ -1632,14 +1712,14 @@ class AgentResponse(Agent):
         ),
     ]
     linked_twitter_username: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Linked Twitter username",
         ),
     ]
     linked_twitter_name: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Linked Twitter display name",
@@ -1660,14 +1740,14 @@ class AgentResponse(Agent):
         ),
     ]
     linked_telegram_username: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Linked Telegram username",
         ),
     ]
     linked_telegram_name: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Linked Telegram display name",
@@ -1706,7 +1786,7 @@ class AgentResponse(Agent):
 
     @classmethod
     async def from_agent(
-        cls, agent: Agent, agent_data: Optional[AgentData] = None
+        cls, agent: Agent, agent_data: AgentData | None = None
     ) -> "AgentResponse":
         """Create an AgentResponse from an Agent instance.
 
@@ -1731,8 +1811,7 @@ class AgentResponse(Agent):
             linked_twitter_name = agent_data.twitter_name
             if agent_data.twitter_access_token_expires_at:
                 has_twitter_linked = (
-                    agent_data.twitter_access_token_expires_at
-                    > datetime.now(timezone.utc)
+                    agent_data.twitter_access_token_expires_at > datetime.now(UTC)
                 )
             else:
                 has_twitter_linked = True
@@ -1823,6 +1902,7 @@ class AgentResponse(Agent):
             "frequency_penalty",
             "telegram_entrypoint_prompt",
             "telegram_config",
+            "discord_config",
             "xmtp_entrypoint_prompt",
         }
         for field in privacy_fields: