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

intentkit/models/agent.py

@@ -1,43 +1,47 @@
+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
 from cron_validator import CronValidator
 from epyxid import XID
-from fastapi import HTTPException
-from intentkit.models.agent_data import AgentData
-from intentkit.models.base import Base
-from intentkit.models.credit import CreditAccount
-from intentkit.models.db import get_session
-from intentkit.models.llm import LLMModelInfo, LLMModelInfoTable, LLMProvider
-from intentkit.models.skill import SkillTable
 from pydantic import BaseModel, ConfigDict, field_validator
 from pydantic import Field as PydanticField
 from pydantic.json_schema import SkipJsonSchema
-from sqlalchemy import (
-    Boolean,
-    Column,
-    DateTime,
-    Float,
-    Numeric,
-    String,
-    func,
-    select,
-)
+from pydantic.main import IncEx
+from sqlalchemy import Boolean, DateTime, Float, Numeric, String, func, select
 from sqlalchemy.dialects.postgresql import JSON, JSONB
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Mapped, mapped_column
+
+from intentkit.models.agent_data import AgentData
+from intentkit.models.base import Base
+from intentkit.models.credit import CreditAccount
+from intentkit.models.db import get_session
+from intentkit.models.llm import LLMModelInfo, LLMProvider
+from intentkit.models.skill import Skill
+from intentkit.utils.ens import resolve_ens_to_address
+from intentkit.utils.error import IntentKitAPIError
 
 logger = logging.getLogger(__name__)
 
 
+ENS_NAME_PATTERN = re.compile(
+    r"^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+(?:eth|base\.eth)$",
+    re.IGNORECASE,
+)
+
+
 class AgentAutonomous(BaseModel):
     """Autonomous agent configuration."""
 
@@ -55,7 +59,7 @@ class AgentAutonomous(BaseModel):
         ),
     ]
     name: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Display name of the autonomous configuration",
@@ -66,7 +70,7 @@ class AgentAutonomous(BaseModel):
         ),
     ]
     description: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Description of the autonomous configuration",
@@ -77,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",
@@ -87,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",
@@ -107,7 +111,7 @@ class AgentAutonomous(BaseModel):
         ),
     ]
     enabled: Annotated[
-        Optional[bool],
+        bool | None,
         PydanticField(
             default=False,
             description="Whether the autonomous configuration is enabled",
@@ -140,7 +144,7 @@ class AgentExample(BaseModel):
             description="Name of the example",
             max_length=50,
             json_schema_extra={
-                "x-group": "examples",
+                "x-placeholder": "Add a name for the example",
             },
         ),
     ]
@@ -150,7 +154,7 @@ class AgentExample(BaseModel):
             description="Description of the example",
             max_length=200,
             json_schema_extra={
-                "x-group": "examples",
+                "x-placeholder": "Add a short description for the example",
             },
         ),
     ]
@@ -160,7 +164,7 @@ class AgentExample(BaseModel):
             description="Example prompt",
             max_length=2000,
             json_schema_extra={
-                "x-group": "examples",
+                "x-placeholder": "The prompt will be sent to the agent",
             },
         ),
     ]
@@ -172,62 +176,62 @@ class AgentUserInputColumns:
     __abstract__ = True
 
     # Basic information fields from AgentCore
-    name = Column(
+    name: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Display name of the agent",
     )
-    picture = Column(
+    picture: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Picture of the agent",
     )
-    purpose = Column(
+    purpose: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Purpose or role of the agent",
     )
-    personality = Column(
+    personality: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Personality traits of the agent",
     )
-    principles = Column(
+    principles: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Principles or values of the agent",
     )
 
     # AI model configuration fields from AgentCore
-    model = Column(
+    model: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         default="gpt-5-mini",
         comment="AI model identifier to be used by this agent for processing requests. Available models: gpt-4o, gpt-4o-mini, deepseek-chat, deepseek-reasoner, grok-2, eternalai",
     )
-    prompt = Column(
+    prompt: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Base system prompt that defines the agent's behavior and capabilities",
     )
-    prompt_append = Column(
+    prompt_append: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Additional system prompt that has higher priority than the base prompt",
     )
-    temperature = Column(
+    temperature: Mapped[float | None] = mapped_column(
         Float,
         nullable=True,
         default=0.7,
         comment="Controls response randomness (0.0~2.0). Higher values increase creativity but may reduce accuracy. For rigorous tasks, use lower values.",
     )
-    frequency_penalty = Column(
+    frequency_penalty: Mapped[float | None] = mapped_column(
         Float,
         nullable=True,
         default=0.0,
         comment="Controls repetition in responses (-2.0~2.0). Higher values reduce repetition, lower values allow more repetition.",
     )
-    presence_penalty = Column(
+    presence_penalty: Mapped[float | None] = mapped_column(
         Float,
         nullable=True,
         default=0.0,
@@ -235,17 +239,17 @@ class AgentUserInputColumns:
     )
 
     # Wallet and network configuration fields from AgentCore
-    wallet_provider = Column(
+    wallet_provider: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Provider of the agent's wallet",
     )
-    readonly_wallet_address = Column(
+    readonly_wallet_address: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Readonly wallet address of the agent",
     )
-    network_id = Column(
+    network_id: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         default="base-mainnet",
@@ -253,41 +257,52 @@ class AgentUserInputColumns:
     )
 
     # Skills configuration from AgentCore
-    skills = Column(
+    skills: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Dict of skills and their corresponding configurations",
     )
 
     # Additional fields from AgentUserInput
-    short_term_memory_strategy = Column(
+    short_term_memory_strategy: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         default="trim",
         comment="Strategy for managing short-term memory when context limit is reached. 'trim' removes oldest messages, 'summarize' creates summaries.",
     )
-    autonomous = Column(
+    autonomous: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Autonomous agent configurations",
     )
-    telegram_entrypoint_enabled = Column(
+    telegram_entrypoint_enabled: Mapped[bool | None] = mapped_column(
         Boolean,
         nullable=True,
         default=False,
         comment="Whether the agent can receive events from Telegram",
     )
-    telegram_entrypoint_prompt = Column(
+    telegram_entrypoint_prompt: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Extra prompt for telegram entrypoint",
     )
-    telegram_config = Column(
+    telegram_config: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Telegram integration configuration settings",
     )
-    xmtp_entrypoint_prompt = Column(
+    discord_entrypoint_enabled: Mapped[bool | None] = mapped_column(
+        Boolean,
+        nullable=True,
+        default=False,
+        comment="Whether the agent can receive events from Discord",
+    )
+    discord_config: Mapped[dict[str, Any] | None] = mapped_column(
+        JSON().with_variant(JSONB(), "postgresql"),
+        nullable=True,
+        comment="Discord integration configuration settings",
+    )
+    xmtp_entrypoint_prompt: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Extra prompt for xmtp entrypoint",
@@ -299,112 +314,137 @@ class AgentTable(Base, AgentUserInputColumns):
 
     __tablename__ = "agents"
 
-    id = Column(
+    id: Mapped[str] = mapped_column(
         String,
         primary_key=True,
         comment="Unique identifier for the agent. Must be URL-safe, containing only lowercase letters, numbers, and hyphens",
     )
-    slug = Column(
+    slug: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Slug of the agent, used for URL generation",
     )
-    owner = Column(
+    owner: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Owner identifier of the agent, used for access control",
     )
-    upstream_id = Column(
+    team_id: Mapped[str | None] = mapped_column(
+        String,
+        nullable=True,
+        comment="Team identifier of the agent, used for access control",
+    )
+    upstream_id: Mapped[str | None] = mapped_column(
         String,
         index=True,
         nullable=True,
         comment="Upstream reference ID for idempotent operations",
     )
-    upstream_extra = Column(
+    upstream_extra: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Additional data store for upstream use",
     )
-    version = Column(
+    version: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Version hash of the agent",
     )
-    statistics = Column(
+    statistics: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Statistics of the agent, update every 1 hour for query",
     )
-    assets = Column(
+    assets: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Assets of the agent, update every 1 hour for query",
     )
-    account_snapshot = Column(
+    account_snapshot: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Account snapshot of the agent, update every 1 hour for query",
     )
-    extra = Column(
+    extra: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Other helper data fields for query, come from agent and agent data",
     )
 
     # Fields moved from AgentUserInputColumns that are no longer in AgentUserInput
-    description = Column(
+    description: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Description of the agent, for public view, not contained in prompt",
     )
-    external_website = Column(
+    external_website: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Link of external website of the agent, if you have one",
     )
-    ticker = Column(
+    ticker: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Ticker symbol of the agent",
     )
-    token_address = Column(
+    token_address: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Token address of the agent",
     )
-    token_pool = Column(
+    token_pool: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Pool of the agent token",
     )
-    fee_percentage = Column(
+    fee_percentage: Mapped[Decimal | None] = mapped_column(
         Numeric(22, 4),
         nullable=True,
         comment="Fee percentage of the agent",
     )
-    example_intro = Column(
+    example_intro: Mapped[str | None] = mapped_column(
         String,
         nullable=True,
         comment="Introduction for example interactions",
     )
-    examples = Column(
+    examples: Mapped[dict[str, Any] | None] = mapped_column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="List of example interactions for the agent",
     )
+    public_extra: Mapped[dict[str, Any] | None] = mapped_column(
+        JSON().with_variant(JSONB(), "postgresql"),
+        nullable=True,
+        comment="Public extra data of the agent",
+    )
+    deployed_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True),
+        nullable=True,
+        comment="Timestamp when the agent was deployed",
+    )
+    public_info_updated_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True),
+        nullable=True,
+        comment="Timestamp when the agent public info was last updated",
+    )
+    x402_price: Mapped[float | None] = mapped_column(
+        Float,
+        nullable=True,
+        comment="Price of the x402 request",
+    )
 
     # auto timestamp
-    created_at = Column(
+    created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         nullable=False,
         server_default=func.now(),
         comment="Timestamp when the agent was created",
     )
-    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),
         comment="Timestamp when the agent was last updated",
     )
 
@@ -413,75 +453,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
@@ -489,128 +497,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"]],
+        Literal["cdp", "readonly", "none"] | None,
         PydanticField(
-            default="cdp",
+            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[
-                "ethereum-mainnet",
-                "ethereum-sepolia",
-                "polygon-mainnet",
-                "polygon-mumbai",
-                "base-mainnet",
-                "base-sepolia",
-                "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,
-            },
         ),
     ]
 
@@ -647,21 +613,21 @@ class AgentUserInput(AgentCore):
     model_config = ConfigDict(
         title="AgentUserInput",
         from_attributes=True,
+        json_schema_extra={
+            "required": ["name"],
+        },
     )
 
     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=(
@@ -678,53 +644,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[str, object] | 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",
-            },
         ),
     ]
 
@@ -741,7 +711,7 @@ class AgentUpdate(AgentUserInput):
     )
 
     upstream_id: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="External reference ID for idempotent operations",
@@ -749,7 +719,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",
@@ -761,7 +731,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
@@ -788,20 +758,25 @@ class AgentUpdate(AgentUserInput):
         for autonomous_config in self.autonomous:
             # Check that exactly one scheduling method is provided
             if not autonomous_config.minutes and not autonomous_config.cron:
-                raise HTTPException(
-                    status_code=400, detail="either minutes or cron must have a value"
+                raise IntentKitAPIError(
+                    status_code=400,
+                    key="InvalidAutonomousConfig",
+                    message="either minutes or cron must have a value",
                 )
 
             if autonomous_config.minutes and autonomous_config.cron:
-                raise HTTPException(
-                    status_code=400, detail="only one of minutes or cron can be set"
+                raise IntentKitAPIError(
+                    status_code=400,
+                    key="InvalidAutonomousConfig",
+                    message="only one of minutes or cron can be set",
                 )
 
             # Validate minimum interval of 5 minutes
             if autonomous_config.minutes and autonomous_config.minutes < 5:
-                raise HTTPException(
+                raise IntentKitAPIError(
                     status_code=400,
-                    detail="The shortest execution interval is 5 minutes",
+                    key="InvalidAutonomousInterval",
+                    message="The shortest execution interval is 5 minutes",
                 )
 
             # Validate cron expression to ensure interval is at least 5 minutes
@@ -811,15 +786,18 @@ class AgentUpdate(AgentUserInput):
                 try:
                     CronValidator.parse(autonomous_config.cron)
                 except ValueError:
-                    raise HTTPException(
+                    raise IntentKitAPIError(
                         status_code=400,
-                        detail=f"Invalid cron expression format: {autonomous_config.cron}",
+                        key="InvalidCronExpression",
+                        message=f"Invalid cron expression format: {autonomous_config.cron}",
                     )
 
                 parts = autonomous_config.cron.split()
                 if len(parts) < 5:
-                    raise HTTPException(
-                        status_code=400, detail="Invalid cron expression format"
+                    raise IntentKitAPIError(
+                        status_code=400,
+                        key="InvalidCronExpression",
+                        message="Invalid cron expression format",
                     )
 
                 minute, hour, day_of_month, month, day_of_week = parts[:5]
@@ -827,25 +805,28 @@ class AgentUpdate(AgentUserInput):
                 # Check if minutes or hours have too frequent intervals
                 if "*" in minute and "*" in hour:
                     # If both minute and hour are wildcards, it would run every minute
-                    raise HTTPException(
+                    raise IntentKitAPIError(
                         status_code=400,
-                        detail="The shortest execution interval is 5 minutes",
+                        key="InvalidAutonomousInterval",
+                        message="The shortest execution interval is 5 minutes",
                     )
 
                 if "/" in minute:
                     # Check step value in minute field (e.g., */15)
                     step = int(minute.split("/")[1])
                     if step < 5 and hour == "*":
-                        raise HTTPException(
+                        raise IntentKitAPIError(
                             status_code=400,
-                            detail="The shortest execution interval is 5 minutes",
+                            key="InvalidAutonomousInterval",
+                            message="The shortest execution interval is 5 minutes",
                         )
 
                 # Check for comma-separated values or ranges that might result in multiple executions per hour
                 if ("," in minute or "-" in minute) and hour == "*":
-                    raise HTTPException(
+                    raise IntentKitAPIError(
                         status_code=400,
-                        detail="The shortest execution interval is 5 minutes",
+                        key="InvalidAutonomousInterval",
+                        message="The shortest execution interval is 5 minutes",
                     )
 
     # deprecated, use override instead
@@ -857,10 +838,16 @@ class AgentUpdate(AgentUserInput):
         async with get_session() as db:
             db_agent = await db.get(AgentTable, id)
             if not db_agent:
-                raise HTTPException(status_code=404, detail="Agent not found")
+                raise IntentKitAPIError(
+                    status_code=404,
+                    key="AgentNotFound",
+                    message="Agent not found",
+                )
             # update
             for key, value in self.model_dump(exclude_unset=True).items():
                 setattr(db_agent, key, value)
+            db_agent.version = self.hash()
+            db_agent.deployed_at = func.now()
             await db.commit()
             await db.refresh(db_agent)
             return Agent.model_validate(db_agent)
@@ -873,12 +860,17 @@ class AgentUpdate(AgentUserInput):
         async with get_session() as db:
             db_agent = await db.get(AgentTable, id)
             if not db_agent:
-                raise HTTPException(status_code=404, detail="Agent not found")
+                raise IntentKitAPIError(
+                    status_code=404,
+                    key="AgentNotFound",
+                    message="Agent not found",
+                )
             # update
             for key, value in self.model_dump().items():
                 setattr(db_agent, key, value)
             # version
             db_agent.version = self.hash()
+            db_agent.deployed_at = func.now()
             await db.commit()
             await db.refresh(db_agent)
             return Agent.model_validate(db_agent)
@@ -898,13 +890,21 @@ class AgentCreate(AgentUpdate):
         ),
     ]
     owner: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Owner identifier of the agent, used for access control",
             max_length=50,
         ),
     ]
+    team_id: Annotated[
+        str | None,
+        PydanticField(
+            default=None,
+            description="Team identifier of the agent",
+            max_length=50,
+        ),
+    ]
 
     async def check_upstream_id(self) -> None:
         if not self.upstream_id:
@@ -914,12 +914,13 @@ class AgentCreate(AgentUpdate):
                 select(AgentTable).where(AgentTable.upstream_id == self.upstream_id)
             )
             if existing:
-                raise HTTPException(
+                raise IntentKitAPIError(
                     status_code=400,
-                    detail="Upstream id already in use",
+                    key="UpstreamIdConflict",
+                    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:
@@ -936,12 +937,21 @@ class AgentCreate(AgentUpdate):
             self.validate_autonomous_schedule()
 
         async with get_session() as db:
-            db_agent = AgentTable(**self.model_dump())
-            db_agent.version = self.hash()
-            db.add(db_agent)
-            await db.commit()
-            await db.refresh(db_agent)
-            return Agent.model_validate(db_agent)
+            try:
+                db_agent = AgentTable(**self.model_dump())
+                db_agent.version = self.hash()
+                db_agent.deployed_at = func.now()
+                db.add(db_agent)
+                await db.commit()
+                await db.refresh(db_agent)
+                return Agent.model_validate(db_agent)
+            except IntegrityError:
+                await db.rollback()
+                raise IntentKitAPIError(
+                    status_code=400,
+                    key="AgentExists",
+                    message=f"Agent with ID '{self.id}' already exists",
+                )
 
 
 class AgentPublicInfo(BaseModel):
@@ -952,100 +962,188 @@ class AgentPublicInfo(BaseModel):
         from_attributes=True,
     )
 
+    x402_price: Annotated[
+        float | None,
+        PydanticField(
+            default=0.01,
+            description="Price($) of the x402 request",
+            ge=0.01,
+            le=1.0,
+            json_schema_extra={
+                "x-placeholder": "USDC price per request",
+                "x-step": 0.01,
+            },
+        ),
+    ]
     description: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Description of the agent, for public view, not contained in prompt",
             json_schema_extra={
-                "x-group": "basic",
                 "x-placeholder": "Introduce your agent",
             },
         ),
     ]
     external_website: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Link of external website of the agent, if you have one",
             json_schema_extra={
-                "x-group": "basic",
                 "x-placeholder": "Enter agent external website url",
                 "format": "uri",
             },
         ),
     ]
     ticker: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Ticker symbol of the agent",
             max_length=10,
             min_length=1,
             json_schema_extra={
-                "x-group": "basic",
                 "x-placeholder": "If one day, your agent has it's own token, what will it be?",
             },
         ),
     ]
     token_address: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Token address of the agent",
-            max_length=42,
+            max_length=66,
             json_schema_extra={
-                "x-group": "internal",
-                "readOnly": True,
+                "x-placeholder": "The contract address of the agent token",
             },
         ),
     ]
     token_pool: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Pool of the agent token",
-            max_length=42,
+            max_length=66,
             json_schema_extra={
-                "x-group": "internal",
-                "readOnly": True,
+                "x-placeholder": "The contract address of the agent token pool",
             },
         ),
     ]
     fee_percentage: Annotated[
-        Optional[Decimal],
+        Decimal | None,
         PydanticField(
             default=None,
             description="Fee percentage of the agent",
             ge=Decimal("0.0"),
             json_schema_extra={
-                "x-group": "basic",
+                "x-placeholder": "Agent will charge service fee according to this ratio.",
             },
         ),
     ]
     example_intro: Annotated[
-        Optional[str],
+        str | None,
         PydanticField(
             default=None,
             description="Introduction of the example",
             max_length=2000,
             json_schema_extra={
-                "x-group": "examples",
+                "x-placeholder": "Add a short introduction in new chat",
             },
         ),
     ]
     examples: Annotated[
-        Optional[List[AgentExample]],
+        list[AgentExample] | None,
         PydanticField(
             default=None,
             description="List of example prompts for the agent",
             max_length=6,
             json_schema_extra={
-                "x-group": "examples",
                 "x-inline": True,
             },
         ),
     ]
+    public_extra: Annotated[
+        dict[str, Any] | None,
+        PydanticField(
+            default=None,
+            description="Public extra data of the agent",
+        ),
+    ]
+
+    async def update(self, agent_id: str) -> "Agent":
+        """Update agent public info with only the fields that are explicitly provided.
+
+        This method only updates fields that are explicitly set in this instance,
+        leaving other fields unchanged. This is more efficient than override as it
+        reduces context usage and minimizes the risk of accidentally changing fields.
+
+        Args:
+            agent_id: The ID of the agent to update
+
+        Returns:
+            The updated Agent instance
+        """
+        async with get_session() as session:
+            # Get the agent from database
+            result = await session.execute(
+                select(AgentTable).where(AgentTable.id == agent_id)
+            )
+            db_agent = result.scalar_one_or_none()
+
+            if not db_agent:
+                raise IntentKitAPIError(404, "NotFound", f"Agent {agent_id} not found")
+
+            # Get only the fields that are explicitly provided (exclude_unset=True)
+            update_data = self.model_dump(exclude_unset=True)
+
+            # Apply the updates to the database agent
+            for key, value in update_data.items():
+                if hasattr(db_agent, key):
+                    setattr(db_agent, key, value)
+
+            # Update public_info_updated_at timestamp
+            db_agent.public_info_updated_at = func.now()
+
+            # Commit changes
+            await session.commit()
+            await session.refresh(db_agent)
+
+            return Agent.model_validate(db_agent)
+
+    async def override(self, agent_id: str) -> "Agent":
+        """Override agent public info with all fields from this instance.
+
+        Args:
+            agent_id: The ID of the agent to override
+
+        Returns:
+            The updated Agent instance
+        """
+        async with get_session() as session:
+            # Get the agent from database
+            result = await session.execute(
+                select(AgentTable).where(AgentTable.id == agent_id)
+            )
+            db_agent = result.scalar_one_or_none()
+
+            if not db_agent:
+                raise IntentKitAPIError(404, "NotFound", f"Agent {agent_id} not found")
+
+            # Update public info fields
+            update_data = self.model_dump()
+            for key, value in update_data.items():
+                if hasattr(db_agent, key):
+                    setattr(db_agent, key, value)
+
+            # Update public_info_updated_at timestamp
+            db_agent.public_info_updated_at = func.now()
+
+            # Commit changes
+            await session.commit()
+            await session.refresh(db_agent)
+
+            return Agent.model_validate(db_agent)
 
 
 class Agent(AgentCreate, AgentPublicInfo):
@@ -1054,43 +1152,64 @@ 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",
-            max_length=20,
+            max_length=100,
             min_length=2,
         ),
     ]
     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(
-            description="Statistics of the agent, update every 1 hour for query"
+            default=None,
+            description="Statistics of the agent, update every 1 hour for query",
         ),
     ]
     assets: Annotated[
-        Optional[Dict[str, Any]],
-        PydanticField(description="Assets of the agent, update every 1 hour for query"),
+        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(
-            description="Account snapshot of the agent, update every 1 hour for query"
+            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(
-            description="Other helper data fields for query, come from agent and agent data"
+            default=None,
+            description="Other helper data fields for query, come from agent and agent data",
         ),
     ]
+    deployed_at: Annotated[
+        datetime | None,
+        PydanticField(
+            default=None,
+            description="Timestamp when the agent was deployed",
+        ),
+    ]
+    public_info_updated_at: Annotated[
+        datetime | None,
+        PydanticField(
+            default=None,
+            description="Timestamp when the agent public info was last updated",
+        ),
+    ]
+
     # auto timestamp
     created_at: Annotated[
         datetime,
@@ -1125,8 +1244,37 @@ 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 has_search(self) -> bool:
+        texts = [
+            self.prompt,
+            self.prompt_append,
+            self.purpose,
+            self.personality,
+            self.principles,
+        ]
+        for t in texts:
+            if t and (re.search(r"@search\b", t) or re.search(r"@web\b", t)):
+                return True
+        return False
+
+    def has_super(self) -> bool:
+        texts = [
+            self.prompt,
+            self.prompt_append,
+            self.purpose,
+            self.personality,
+            self.principles,
+        ]
+        for t in texts:
+            if t and re.search(r"@super\b", t):
+                return True
+        return False
 
     def to_yaml(self) -> str:
         """
@@ -1219,7 +1367,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]
@@ -1234,20 +1382,22 @@ class Agent(AgentCreate, AgentPublicInfo):
                 yaml_lines.append(indented_yaml.rstrip())
             elif hasattr(value, "model_dump"):
                 # Handle individual Pydantic model
-                model_dict = value.model_dump(exclude_none=True)
+                yaml_lines.append(f"{field_name}:")
                 yaml_value = yaml.dump(
-                    {field_name: model_dict},
+                    value.model_dump(exclude_none=True),
                     default_flow_style=False,
                     allow_unicode=True,
                 )
-                yaml_lines.append(yaml_value.rstrip())
+                # Indent all lines and append to yaml_lines
+                indented_yaml = "\n".join(
+                    f"  {line}" for line in yaml_value.split("\n") if line.strip()
+                )
+                yaml_lines.append(indented_yaml)
             else:
-                # Handle Decimal values specifically
+                # Handle Decimal and other types
                 if isinstance(value, Decimal):
-                    # Convert Decimal to string to avoid !!python/object/apply:decimal.Decimal serialization
-                    yaml_lines.append(f"{field_name}: {value}")
+                    yaml_lines.append(f"{field_name}: {str(value)}")
                 else:
-                    # Handle other non-string values
                     yaml_value = yaml.dump(
                         {field_name: value},
                         default_flow_style=False,
@@ -1263,18 +1413,158 @@ 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
+        """
+        query_id = agent_id
+        if ENS_NAME_PATTERN.fullmatch(agent_id):
+            query_id = await resolve_ens_to_address(agent_id)
+
+        async with get_session() as db:
+            agent = None
+
+            # Try to get by ID if length <= 20
+            if len(query_id) <= 20 or query_id.startswith("0x"):
+                agent = await Agent.get(query_id)
+
+            # If not found, try to get by slug
+            if agent is None:
+                slug_stmt = select(AgentTable).where(AgentTable.slug == query_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
@@ -1293,8 +1583,7 @@ class Agent(AgentCreate, AgentPublicInfo):
         cls,
         db: AsyncSession = None,
         filter_owner_api_skills: bool = False,
-        admin_llm_skill_control: bool = True,
-    ) -> Dict:
+    ) -> dict:
         """Get the JSON schema for Agent model with all $ref references resolved.
 
         This is the shared function that handles admin configuration filtering
@@ -1303,7 +1592,6 @@ class Agent(AgentCreate, AgentPublicInfo):
         Args:
             db: Database session (optional, will create if not provided)
             filter_owner_api_skills: Whether to filter out skills that require agent owner API keys
-            admin_llm_skill_control: Whether to enable admin LLM and skill control features
 
         Returns:
             Dict containing the complete JSON schema for the Agent model
@@ -1311,9 +1599,7 @@ class Agent(AgentCreate, AgentPublicInfo):
         # Get database session if not provided
         if db is None:
             async with get_session() as session:
-                return await cls.get_json_schema(
-                    session, filter_owner_api_skills, admin_llm_skill_control
-                )
+                return await cls.get_json_schema(session, filter_owner_api_skills)
 
         # Get the schema file path relative to this file
         current_dir = Path(__file__).parent
@@ -1326,214 +1612,260 @@ class Agent(AgentCreate, AgentPublicInfo):
             # Get the model property from the schema
             model_property = schema.get("properties", {}).get("model", {})
 
-            if admin_llm_skill_control:
-                # Process model property - use LLMModelInfo as primary source
-                if model_property:
-                    # Query all LLM models from the database
-                    stmt = select(LLMModelInfoTable).where(LLMModelInfoTable.enabled)
-                    result = await db.execute(stmt)
-                    models = result.scalars().all()
-
-                    # Create new lists based on LLMModelInfo
-                    new_enum = []
-                    new_enum_title = []
-                    new_enum_category = []
-                    new_enum_support_skill = []
-
-                    # Process each model from database
-                    for model in models:
-                        model_info = LLMModelInfo.model_validate(model)
-
-                        # Add model ID to enum
-                        new_enum.append(model_info.id)
-
-                        # Add model name as title
-                        new_enum_title.append(model_info.name)
-
-                        # Add provider display name as category
-                        provider = (
-                            LLMProvider(model_info.provider)
-                            if isinstance(model_info.provider, str)
-                            else model_info.provider
-                        )
-                        new_enum_category.append(provider.display_name())
-
-                        # Add skill support information
-                        new_enum_support_skill.append(model_info.supports_skill_calls)
-
-                    # Update the schema with the new lists constructed from LLMModelInfo
-                    model_property["enum"] = new_enum
-                    model_property["x-enum-title"] = new_enum_title
-                    model_property["x-enum-category"] = new_enum_category
-                    model_property["x-support-skill"] = new_enum_support_skill
-
-                    # If the default model is not in the new enum, update it if possible
-                    if (
-                        "default" in model_property
-                        and model_property["default"] not in new_enum
-                        and new_enum
-                    ):
-                        model_property["default"] = new_enum[0]
-
-                # Process skills property
-                skills_property = schema.get("properties", {}).get("skills", {})
-                skills_properties = skills_property.get("properties", {})
-
-                if skills_properties:
-                    # Load all skills from the database
-                    # Query all skills grouped by category with enabled status
-                    stmt = select(
-                        SkillTable.category,
-                        func.bool_or(SkillTable.enabled).label("any_enabled"),
-                    ).group_by(SkillTable.category)
-                    result = await db.execute(stmt)
-                    category_status = {row.category: row.any_enabled for row in result}
-
-                    # Query all skills with their price levels for adding x-price-level fields
-                    skills_stmt = select(
-                        SkillTable.category,
-                        SkillTable.config_name,
-                        SkillTable.price_level,
-                        SkillTable.enabled,
-                    ).where(SkillTable.enabled)
-                    skills_result = await db.execute(skills_stmt)
-                    skills_data = {}
-                    category_price_levels = {}
-
-                    for row in skills_result:
-                        if row.category not in skills_data:
-                            skills_data[row.category] = {}
-                            category_price_levels[row.category] = []
-
-                        if row.config_name:
-                            skills_data[row.category][row.config_name] = row.price_level
-
-                        if row.price_level is not None:
-                            category_price_levels[row.category].append(row.price_level)
-
-                    # Calculate average price levels for categories
-                    category_avg_price_levels = {}
-                    for category, price_levels in category_price_levels.items():
-                        if price_levels:
-                            avg_price_level = int(sum(price_levels) / len(price_levels))
-                            category_avg_price_levels[category] = avg_price_level
-
-                    # Create a copy of keys to avoid modifying during iteration
-                    skill_keys = list(skills_properties.keys())
-
-                    # Process each skill in the schema
-                    for skill_category in skill_keys:
-                        if skill_category not in category_status:
-                            # If category not found in database, remove it from schema
-                            skills_properties.pop(skill_category, None)
-                        elif not category_status[skill_category]:
-                            # If category exists but all skills are disabled, remove it
-                            skills_properties.pop(skill_category, None)
-                        elif filter_owner_api_skills and cls._is_agent_owner_only_skill(
-                            skills_properties[skill_category]
+            # Process model property using defaults merged with database overrides
+            if model_property:
+                new_enum = []
+                new_enum_title = []
+                new_enum_category = []
+                new_enum_support_skill = []
+
+                for model_info in await LLMModelInfo.get_all(db):
+                    if not model_info.enabled:
+                        continue
+
+                    provider = (
+                        LLMProvider(model_info.provider)
+                        if isinstance(model_info.provider, str)
+                        else model_info.provider
+                    )
+
+                    new_enum.append(model_info.id)
+                    new_enum_title.append(model_info.name)
+                    new_enum_category.append(provider.display_name())
+                    new_enum_support_skill.append(model_info.supports_skill_calls)
+
+                model_property["enum"] = new_enum
+                model_property["x-enum-title"] = new_enum_title
+                model_property["x-enum-category"] = new_enum_category
+                model_property["x-support-skill"] = new_enum_support_skill
+
+                if (
+                    "default" in model_property
+                    and model_property["default"] not in new_enum
+                    and new_enum
+                ):
+                    model_property["default"] = new_enum[0]
+
+            # Process skills property using data from Skill.get_all instead of agent_schema.json
+            skills_property = schema.get("properties", {}).get("skills", {})
+
+            # Build skill_states_map from database
+            skill_states_map: dict[str, dict[str, Skill]] = {}
+            for skill_model in await Skill.get_all(db):
+                if not skill_model.config_name:
+                    continue
+                category_states = skill_states_map.setdefault(skill_model.category, {})
+                if skill_model.enabled:
+                    category_states[skill_model.config_name] = skill_model
+                else:
+                    category_states.pop(skill_model.config_name, None)
+
+            enabled_categories = {
+                category for category, states in skill_states_map.items() if states
+            }
+
+            # Calculate price levels and skills data
+            category_avg_price_levels = {}
+            skills_data = {}
+            for category, states in skill_states_map.items():
+                if not states:
+                    continue
+                price_levels = [
+                    state.price_level
+                    for state in states.values()
+                    if state.price_level is not None
+                ]
+                if price_levels:
+                    category_avg_price_levels[category] = int(
+                        sum(price_levels) / len(price_levels)
+                    )
+                skills_data[category] = {
+                    config_name: state.price_level
+                    for config_name, state in states.items()
+                }
+
+            # Dynamically generate skills_properties from Skill.get_all data
+            skills_properties = {}
+            current_dir = Path(__file__).parent
+
+            for category in enabled_categories:
+                # Skip if filtered for auto-generation
+                skill_schema_path = current_dir / f"../skills/{category}/schema.json"
+                if skill_schema_path.exists():
+                    try:
+                        with open(skill_schema_path) as f:
+                            skill_schema = json.load(f)
+
+                        # Check if this skill should be filtered for owner API requirements
+                        if filter_owner_api_skills and cls._is_agent_owner_only_skill(
+                            skill_schema
                         ):
-                            # If filtering owner API skills and this skill requires it, remove it
-                            skills_properties.pop(skill_category, None)
                             logger.info(
-                                f"Filtered out skill '{skill_category}' from auto-generation: requires agent owner API key"
+                                f"Filtered out skill '{category}' from auto-generation: requires agent owner API key"
                             )
-                        else:
-                            # Add x-avg-price-level to category level
-                            if skill_category in category_avg_price_levels:
-                                skills_properties[skill_category][
-                                    "x-avg-price-level"
-                                ] = category_avg_price_levels[skill_category]
-
-                            # Add x-price-level to individual skill states
-                            if skill_category in skills_data:
-                                skill_states = (
-                                    skills_properties[skill_category]
-                                    .get("properties", {})
-                                    .get("states", {})
-                                    .get("properties", {})
-                                )
-                                for state_name, state_config in skill_states.items():
-                                    if (
-                                        state_name in skills_data[skill_category]
-                                        and skills_data[skill_category][state_name]
-                                        is not None
-                                    ):
-                                        state_config["x-price-level"] = skills_data[
-                                            skill_category
-                                        ][state_name]
+                            continue
+
+                        # Create skill property with embedded schema instead of reference
+                        # Load and embed the full skill schema directly
+                        base_uri = f"file://{skill_schema_path}"
+                        with open(skill_schema_path) as f:
+                            embedded_skill_schema = jsonref.load(
+                                f, base_uri=base_uri, proxies=False, lazy_load=False
+                            )
+
+                        skills_properties[category] = {
+                            "title": skill_schema.get("title", category.title()),
+                            **embedded_skill_schema,  # Embed the full schema instead of using $ref
+                        }
+
+                        # Add price level information
+                        if category in category_avg_price_levels:
+                            skills_properties[category]["x-avg-price-level"] = (
+                                category_avg_price_levels[category]
+                            )
+
+                        if category in skills_data:
+                            # Add price level to states in the embedded schema
+                            skill_states = (
+                                skills_properties[category]
+                                .get("properties", {})
+                                .get("states", {})
+                                .get("properties", {})
+                            )
+                            for state_name, state_config in skill_states.items():
+                                if (
+                                    state_name in skills_data[category]
+                                    and skills_data[category][state_name] is not None
+                                ):
+                                    state_config["x-price-level"] = skills_data[
+                                        category
+                                    ][state_name]
+                    except (FileNotFoundError, json.JSONDecodeError) as e:
+                        logger.warning(
+                            f"Could not load schema for skill category '{category}': {e}"
+                        )
+                        continue
+
+            # Update the skills property in the schema
+            if skills_property:
+                skills_property["properties"] = skills_properties
 
             # Log the changes for debugging
             logger.debug(
-                f"Schema processed with LLM and skill controls enabled: {admin_llm_skill_control}, "
-                f"filtered owner API skills: {filter_owner_api_skills}"
+                "Schema processed with merged LLM/skill defaults; filtered owner API skills: %s",
+                filter_owner_api_skills,
             )
 
             return schema
 
 
 class AgentResponse(Agent):
-    """Response model for Agent API."""
+    """Agent response model that excludes sensitive fields from JSON output and schema."""
 
     model_config = ConfigDict(
-        use_enum_values=True,
+        title="AgentPublic",
         from_attributes=True,
-        json_encoders={
-            datetime: lambda dt: dt.isoformat(),
-        },
+        # json_encoders={
+        #     datetime: lambda v: v.isoformat(timespec="milliseconds"),
+        # },
     )
 
-    # data part
+    # Override privacy fields to exclude them from JSON schema
+    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], PydanticField(description="CDP wallet address for the agent")
+        str | None,
+        PydanticField(
+            default=None,
+            description="CDP wallet address of the agent",
+        ),
     ]
     evm_wallet_address: Annotated[
-        Optional[str], PydanticField(description="EVM wallet address for the agent")
+        str | None,
+        PydanticField(
+            default=None,
+            description="EVM wallet address of the agent",
+        ),
     ]
     solana_wallet_address: Annotated[
-        Optional[str], PydanticField(description="Solana wallet address for the agent")
+        str | None,
+        PydanticField(
+            default=None,
+            description="Solana wallet address of the agent",
+        ),
     ]
     has_twitter_linked: Annotated[
         bool,
-        PydanticField(description="Whether the agent has linked their Twitter account"),
+        PydanticField(
+            default=False,
+            description="Whether the agent has Twitter linked",
+        ),
     ]
     linked_twitter_username: Annotated[
-        Optional[str],
-        PydanticField(description="The username of the linked Twitter account"),
+        str | None,
+        PydanticField(
+            default=None,
+            description="Linked Twitter username",
+        ),
     ]
     linked_twitter_name: Annotated[
-        Optional[str],
-        PydanticField(description="The name of the linked Twitter account"),
+        str | None,
+        PydanticField(
+            default=None,
+            description="Linked Twitter display name",
+        ),
     ]
     has_twitter_self_key: Annotated[
         bool,
         PydanticField(
-            description="Whether the agent has self-keyed their Twitter account"
+            default=False,
+            description="Whether the agent has Twitter self key",
         ),
     ]
     has_telegram_self_key: Annotated[
         bool,
         PydanticField(
-            description="Whether the agent has self-keyed their Telegram account"
+            default=False,
+            description="Whether the agent has Telegram self key",
         ),
     ]
     linked_telegram_username: Annotated[
-        Optional[str],
-        PydanticField(description="The username of the linked Telegram account"),
+        str | None,
+        PydanticField(
+            default=None,
+            description="Linked Telegram username",
+        ),
     ]
     linked_telegram_name: Annotated[
-        Optional[str],
-        PydanticField(description="The name of the linked Telegram account"),
+        str | None,
+        PydanticField(
+            default=None,
+            description="Linked Telegram display name",
+        ),
     ]
     accept_image_input: Annotated[
         bool,
         PydanticField(
-            description="Whether the agent accepts image inputs in public mode"
+            default=False,
+            description="Whether the agent accepts image input",
         ),
     ]
     accept_image_input_private: Annotated[
         bool,
         PydanticField(
-            description="Whether the agent accepts image inputs in private mode"
+            default=False,
+            description="Whether the agent accepts image input in private mode",
         ),
     ]
 
@@ -1555,7 +1887,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.
 
@@ -1566,76 +1898,6 @@ class AgentResponse(Agent):
         Returns:
             AgentResponse: Response model with additional processed data
         """
-        # Get base data from agent
-        data = agent.model_dump()
-
-        # Hide the sensitive fields
-        data.pop("purpose", None)
-        data.pop("personality", None)
-        data.pop("principles", None)
-        data.pop("prompt", None)
-        data.pop("prompt_append", None)
-        data.pop("temperature", None)
-        data.pop("frequency_penalty", None)
-        data.pop("telegram_entrypoint_prompt", None)
-        data.pop("telegram_config", None)
-        data.pop("xmtp_entrypoint_prompt", None)
-
-        # Filter sensitive fields from autonomous list
-        if data.get("autonomous"):
-            filtered_autonomous = []
-            for item in data["autonomous"]:
-                if isinstance(item, dict):
-                    # Create proper AgentAutonomous instance with only public fields
-                    filtered_autonomous.append(
-                        AgentAutonomous(
-                            id=item.get("id"),
-                            name=item.get("name"),
-                            enabled=item.get("enabled"),
-                            # Set required prompt field to empty string for public view
-                            prompt="",
-                        )
-                    )
-            data["autonomous"] = filtered_autonomous
-
-        # Convert examples dictionaries to AgentExample instances
-        if data.get("examples"):
-            examples_list = []
-            for item in data["examples"]:
-                if isinstance(item, dict):
-                    # Create proper AgentExample instance
-                    examples_list.append(
-                        AgentExample(
-                            name=item.get("name", ""),
-                            description=item.get("description", ""),
-                            prompt=item.get("prompt", ""),
-                        )
-                    )
-            data["examples"] = examples_list
-
-        # Filter sensitive fields from skills dictionary
-        if data.get("skills"):
-            filtered_skills = {}
-            for skill_name, skill_config in data["skills"].items():
-                if isinstance(skill_config, dict):
-                    # Only include skills that are enabled
-                    if skill_config.get("enabled") is True:
-                        filtered_config = {"enabled": True}
-                        # Only keep states with public or private values
-                        if "states" in skill_config and isinstance(
-                            skill_config["states"], dict
-                        ):
-                            filtered_states = {}
-                            for state_key, state_value in skill_config[
-                                "states"
-                            ].items():
-                                if state_value in ["public", "private"]:
-                                    filtered_states[state_key] = state_value
-                            if filtered_states:
-                                filtered_config["states"] = filtered_states
-                        filtered_skills[skill_name] = filtered_config
-            data["skills"] = filtered_skills
-
         # Process CDP wallet address
         cdp_wallet_address = agent_data.evm_wallet_address if agent_data else None
         evm_wallet_address = agent_data.evm_wallet_address if agent_data else None
@@ -1650,8 +1912,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
@@ -1661,10 +1922,10 @@ class AgentResponse(Agent):
             agent_data and agent_data.twitter_self_key_refreshed_at
         )
 
-        # Process Telegram self-key status and remove token
+        # Process Telegram self-key status
         linked_telegram_username = None
         linked_telegram_name = None
-        telegram_config = data.get("telegram_config", {})
+        telegram_config = agent.telegram_config or {}
         has_telegram_self_key = bool(
             telegram_config and "token" in telegram_config and telegram_config["token"]
         )
@@ -1681,22 +1942,174 @@ class AgentResponse(Agent):
             or agent.has_image_parser_skill(is_private=True)
         )
 
-        # Add processed fields to response
-        data.update(
-            {
-                "cdp_wallet_address": cdp_wallet_address,
-                "evm_wallet_address": evm_wallet_address,
-                "solana_wallet_address": solana_wallet_address,
-                "has_twitter_linked": has_twitter_linked,
-                "linked_twitter_username": linked_twitter_username,
-                "linked_twitter_name": linked_twitter_name,
-                "has_twitter_self_key": has_twitter_self_key,
-                "has_telegram_self_key": has_telegram_self_key,
-                "linked_telegram_username": linked_telegram_username,
-                "linked_telegram_name": linked_telegram_name,
-                "accept_image_input": accept_image_input,
-                "accept_image_input_private": accept_image_input_private,
-            }
+        # Create AgentResponse instance directly from agent with additional fields
+        return cls(
+            # Copy all fields from agent
+            **agent.model_dump(),
+            # Add computed fields
+            cdp_wallet_address=cdp_wallet_address,
+            evm_wallet_address=evm_wallet_address,
+            solana_wallet_address=solana_wallet_address,
+            has_twitter_linked=has_twitter_linked,
+            linked_twitter_username=linked_twitter_username,
+            linked_twitter_name=linked_twitter_name,
+            has_twitter_self_key=has_twitter_self_key,
+            has_telegram_self_key=has_telegram_self_key,
+            linked_telegram_username=linked_telegram_username,
+            linked_telegram_name=linked_telegram_name,
+            accept_image_input=accept_image_input,
+            accept_image_input_private=accept_image_input_private,
+        )
+
+    def model_dump(
+        self,
+        *,
+        mode: str | Literal["json", "python"] = "python",
+        include: IncEx | None = None,
+        exclude: IncEx | None = None,
+        context: Any | None = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        round_trip: bool = False,
+        warnings: bool | Literal["none", "warn", "error"] = True,
+        serialize_as_any: bool = False,
+    ) -> dict[str, Any]:
+        """Override model_dump to exclude privacy fields and filter data."""
+        # Get the base model dump
+        data = super().model_dump(
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            context=context,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+            serialize_as_any=serialize_as_any,
+        )
+
+        # Remove privacy fields that might still be present
+        privacy_fields = {
+            "purpose",
+            "personality",
+            "principles",
+            "prompt",
+            "prompt_append",
+            "temperature",
+            "frequency_penalty",
+            "telegram_entrypoint_prompt",
+            "telegram_config",
+            "discord_config",
+            "xmtp_entrypoint_prompt",
+        }
+        for field in privacy_fields:
+            data.pop(field, None)
+
+        # Filter autonomous list to only keep safe fields
+        if "autonomous" in data and data["autonomous"]:
+            filtered_autonomous = []
+            for item in data["autonomous"]:
+                if isinstance(item, dict):
+                    # Only keep safe fields: id, name, description, enabled
+                    filtered_item = {
+                        key: item[key]
+                        for key in ["id", "name", "description", "enabled"]
+                        if key in item
+                    }
+                    filtered_autonomous.append(filtered_item)
+                else:
+                    # Handle AgentAutonomous objects
+                    item_dict = (
+                        item.model_dump() if hasattr(item, "model_dump") else dict(item)
+                    )
+                    # Only keep safe fields: id, name, description, enabled
+                    filtered_item = {
+                        key: item_dict[key]
+                        for key in ["id", "name", "description", "enabled"]
+                        if key in item_dict
+                    }
+                    filtered_autonomous.append(filtered_item)
+            data["autonomous"] = filtered_autonomous
+
+        # Convert examples to AgentExample instances if they're dictionaries
+        if "examples" in data and data["examples"]:
+            converted_examples = []
+            for example in data["examples"]:
+                if isinstance(example, dict):
+                    converted_examples.append(AgentExample(**example).model_dump())
+                else:
+                    converted_examples.append(
+                        example.model_dump()
+                        if hasattr(example, "model_dump")
+                        else example
+                    )
+            data["examples"] = converted_examples
+
+        # Filter skills to only include enabled ones with specific configurations
+        if "skills" in data and data["skills"]:
+            filtered_skills = {}
+            for skill_name, skill_config in data["skills"].items():
+                if (
+                    isinstance(skill_config, dict)
+                    and skill_config.get("enabled") is True
+                ):
+                    # Filter out disabled states from the skill configuration
+                    original_states = skill_config.get("states", {})
+                    filtered_states = {
+                        state_name: state_value
+                        for state_name, state_value in original_states.items()
+                        if state_value != "disabled"
+                    }
+
+                    # Only include the skill if it has at least one non-disabled state
+                    if filtered_states:
+                        filtered_config = {
+                            "enabled": skill_config["enabled"],
+                            "states": filtered_states,
+                        }
+                        # Add other non-sensitive config fields if needed
+                        for key in ["public", "private"]:
+                            if key in skill_config:
+                                filtered_config[key] = skill_config[key]
+                        filtered_skills[skill_name] = filtered_config
+            data["skills"] = filtered_skills
+
+        return data
+
+    def model_dump_json(
+        self,
+        *,
+        indent: int | str | None = None,
+        include: IncEx | None = None,
+        exclude: IncEx | None = None,
+        context: Any | None = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        round_trip: bool = False,
+        warnings: bool | Literal["none", "warn", "error"] = True,
+        serialize_as_any: bool = False,
+    ) -> str:
+        """Override model_dump_json to exclude privacy fields and filter sensitive data."""
+        # Get the filtered data using the same logic as model_dump
+        data = self.model_dump(
+            mode="json",
+            include=include,
+            exclude=exclude,
+            context=context,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+            serialize_as_any=serialize_as_any,
         )
 
-        return cls.model_construct(**data)
+        # Use json.dumps to serialize the filtered data with proper indentation
+        return json.dumps(data, indent=indent, ensure_ascii=False)