intentkit 0.7.4rc1__py3-none-any.whl → 0.7.4rc3__py3-none-any.whl

intentkit/models/agent.py

@@ -1,3 +1,4 @@
+import hashlib
 import json
 import logging
 import re
@@ -14,10 +15,11 @@ 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, model_validator
+from pydantic import BaseModel, ConfigDict, field_validator
 from pydantic import Field as PydanticField
 from pydantic.json_schema import SkipJsonSchema
 from sqlalchemy import (
@@ -128,33 +130,6 @@ class AgentAutonomous(BaseModel):
             )
         return v
 
-    @field_validator("name")
-    @classmethod
-    def validate_name(cls, v: Optional[str]) -> Optional[str]:
-        if v is not None and len(v.encode()) > 50:
-            raise ValueError("name must be at most 50 bytes")
-        return v
-
-    @field_validator("description")
-    @classmethod
-    def validate_description(cls, v: Optional[str]) -> Optional[str]:
-        if v is not None and len(v.encode()) > 200:
-            raise ValueError("description must be at most 200 bytes")
-        return v
-
-    @field_validator("prompt")
-    @classmethod
-    def validate_prompt(cls, v: Optional[str]) -> Optional[str]:
-        if v is not None and len(v.encode()) > 20000:
-            raise ValueError("prompt must be at most 20000 bytes")
-        return v
-
-    @model_validator(mode="after")
-    def validate_schedule(self) -> "AgentAutonomous":
-        # This validator is kept for backward compatibility
-        # The actual validation now happens in AgentUpdate.validate_autonomous_schedule
-        return self
-
 
 class AgentExample(BaseModel):
     """Agent example configuration."""
@@ -191,66 +166,22 @@ class AgentExample(BaseModel):
     ]
 
 
-class AgentTable(Base):
-    """Agent table db model."""
+class AgentUserInputColumns:
+    """Abstract base class containing columns that are common to AgentTable and other tables."""
 
-    __tablename__ = "agents"
+    __abstract__ = True
 
-    id = Column(
-        String,
-        primary_key=True,
-        comment="Unique identifier for the agent. Must be URL-safe, containing only lowercase letters, numbers, and hyphens",
-    )
+    # Basic information fields from AgentCore
     name = Column(
         String,
         nullable=True,
         comment="Display name of the agent",
     )
-    slug = Column(
-        String,
-        nullable=True,
-        comment="Slug of the agent, used for URL generation",
-    )
-    description = Column(
-        String,
-        nullable=True,
-        comment="Description of the agent, for public view, not contained in prompt",
-    )
-    external_website = Column(
-        String,
-        nullable=True,
-        comment="Link of external website of the agent, if you have one",
-    )
     picture = Column(
         String,
         nullable=True,
         comment="Picture of the agent",
     )
-    ticker = Column(
-        String,
-        nullable=True,
-        comment="Ticker symbol of the agent",
-    )
-    token_address = Column(
-        String,
-        nullable=True,
-        comment="Token address of the agent",
-    )
-    token_pool = Column(
-        String,
-        nullable=True,
-        comment="Pool of the agent token",
-    )
-    mode = Column(
-        String,
-        nullable=True,
-        comment="Mode of the agent, public or private",
-    )
-    fee_percentage = Column(
-        Numeric(22, 4),
-        nullable=True,
-        comment="Fee percentage of the agent",
-    )
     purpose = Column(
         String,
         nullable=True,
@@ -266,39 +197,8 @@ class AgentTable(Base):
         nullable=True,
         comment="Principles or values of the agent",
     )
-    owner = Column(
-        String,
-        nullable=True,
-        comment="Owner identifier of the agent, used for access control",
-    )
-    upstream_id = Column(
-        String,
-        index=True,
-        nullable=True,
-        comment="Upstream reference ID for idempotent operations",
-    )
-    upstream_extra = Column(
-        JSON().with_variant(JSONB(), "postgresql"),
-        nullable=True,
-        comment="Additional data store for upstream use",
-    )
-    wallet_provider = Column(
-        String,
-        nullable=True,
-        comment="Provider of the agent's wallet",
-    )
-    readonly_wallet_address = Column(
-        String,
-        nullable=True,
-        comment="Readonly wallet address of the agent",
-    )
-    network_id = Column(
-        String,
-        nullable=True,
-        default="base-mainnet",
-        comment="Network identifier",
-    )
-    # AI part
+
+    # AI model configuration fields from AgentCore
     model = Column(
         String,
         nullable=True,
@@ -333,43 +233,44 @@ class AgentTable(Base):
         default=0.0,
         comment="Controls topic adherence (-2.0~2.0). Higher values allow more topic deviation, lower values enforce stricter topic adherence.",
     )
-    short_term_memory_strategy = Column(
+
+    # Wallet and network configuration fields from AgentCore
+    wallet_provider = 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 mode
-    autonomous = Column(
-        JSON().with_variant(JSONB(), "postgresql"),
-        nullable=True,
-        comment="Autonomous agent configurations",
+        comment="Provider of the agent's wallet",
     )
-    # agent examples
-    example_intro = Column(
+    readonly_wallet_address = Column(
         String,
         nullable=True,
-        comment="Introduction for example interactions",
+        comment="Readonly wallet address of the agent",
     )
-    examples = Column(
-        JSON().with_variant(JSONB(), "postgresql"),
+    network_id = Column(
+        String,
         nullable=True,
-        comment="List of example interactions for the agent",
+        default="base-mainnet",
+        comment="Network identifier",
     )
-    # skills
+
+    # Skills configuration from AgentCore
     skills = Column(
         JSON().with_variant(JSONB(), "postgresql"),
         nullable=True,
         comment="Dict of skills and their corresponding configurations",
     )
 
-    cdp_network_id = Column(
+    # Additional fields from AgentUserInput
+    short_term_memory_strategy = Column(
         String,
         nullable=True,
-        default="base-mainnet",
-        comment="Network identifier for CDP integration",
+        default="trim",
+        comment="Strategy for managing short-term memory when context limit is reached. 'trim' removes oldest messages, 'summarize' creates summaries.",
+    )
+    autonomous = Column(
+        JSON().with_variant(JSONB(), "postgresql"),
+        nullable=True,
+        comment="Autonomous agent configurations",
     )
-    # if telegram_entrypoint_enabled, the telegram_entrypoint_enabled will be enabled, telegram_config will be checked
     telegram_entrypoint_enabled = Column(
         Boolean,
         nullable=True,
@@ -391,6 +292,107 @@ class AgentTable(Base):
         nullable=True,
         comment="Extra prompt for xmtp entrypoint",
     )
+
+
+class AgentTable(Base, AgentUserInputColumns):
+    """Agent table db model."""
+
+    __tablename__ = "agents"
+
+    id = Column(
+        String,
+        primary_key=True,
+        comment="Unique identifier for the agent. Must be URL-safe, containing only lowercase letters, numbers, and hyphens",
+    )
+    slug = Column(
+        String,
+        nullable=True,
+        comment="Slug of the agent, used for URL generation",
+    )
+    owner = Column(
+        String,
+        nullable=True,
+        comment="Owner identifier of the agent, used for access control",
+    )
+    upstream_id = Column(
+        String,
+        index=True,
+        nullable=True,
+        comment="Upstream reference ID for idempotent operations",
+    )
+    upstream_extra = Column(
+        JSON().with_variant(JSONB(), "postgresql"),
+        nullable=True,
+        comment="Additional data store for upstream use",
+    )
+    version = Column(
+        String,
+        nullable=True,
+        comment="Version hash of the agent",
+    )
+    statistics = Column(
+        JSON().with_variant(JSONB(), "postgresql"),
+        nullable=True,
+        comment="Statistics of the agent, update every 1 hour for query",
+    )
+    assets = Column(
+        JSON().with_variant(JSONB(), "postgresql"),
+        nullable=True,
+        comment="Assets of the agent, update every 1 hour for query",
+    )
+    account_snapshot = Column(
+        JSON().with_variant(JSONB(), "postgresql"),
+        nullable=True,
+        comment="Account snapshot of the agent, update every 1 hour for query",
+    )
+    extra = 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(
+        String,
+        nullable=True,
+        comment="Description of the agent, for public view, not contained in prompt",
+    )
+    external_website = Column(
+        String,
+        nullable=True,
+        comment="Link of external website of the agent, if you have one",
+    )
+    ticker = Column(
+        String,
+        nullable=True,
+        comment="Ticker symbol of the agent",
+    )
+    token_address = Column(
+        String,
+        nullable=True,
+        comment="Token address of the agent",
+    )
+    token_pool = Column(
+        String,
+        nullable=True,
+        comment="Pool of the agent token",
+    )
+    fee_percentage = Column(
+        Numeric(22, 4),
+        nullable=True,
+        comment="Fee percentage of the agent",
+    )
+    example_intro = Column(
+        String,
+        nullable=True,
+        comment="Introduction for example interactions",
+    )
+    examples = Column(
+        JSON().with_variant(JSONB(), "postgresql"),
+        nullable=True,
+        comment="List of example interactions for the agent",
+    )
+
     # auto timestamp
     created_at = Column(
         DateTime(timezone=True),
@@ -407,16 +409,8 @@ class AgentTable(Base):
     )
 
 
-class AgentUpdate(BaseModel):
-    """Agent update model."""
-
-    model_config = ConfigDict(
-        title="Agent",
-        from_attributes=True,
-        json_schema_extra={
-            "required": ["name", "purpose", "personality", "principles"],
-        },
-    )
+class AgentCore(BaseModel):
+    """Agent core model."""
 
     name: Annotated[
         Optional[str],
@@ -431,42 +425,6 @@ class AgentUpdate(BaseModel):
             },
         ),
     ]
-    slug: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Slug of the agent, used for URL generation",
-            max_length=30,
-            min_length=2,
-            json_schema_extra={
-                "x-group": "internal",
-                "readOnly": True,
-            },
-        ),
-    ]
-    description: Annotated[
-        Optional[str],
-        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],
-        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",
-            },
-        ),
-    ]
     picture: Annotated[
         Optional[str],
         PydanticField(
@@ -478,64 +436,6 @@ class AgentUpdate(BaseModel):
             },
         ),
     ]
-    ticker: Annotated[
-        Optional[str],
-        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],
-        PydanticField(
-            default=None,
-            description="Token address of the agent",
-            max_length=42,
-            json_schema_extra={
-                "x-group": "internal",
-                "readOnly": True,
-            },
-        ),
-    ]
-    token_pool: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Pool of the agent token",
-            max_length=42,
-            json_schema_extra={
-                "x-group": "internal",
-                "readOnly": True,
-            },
-        ),
-    ]
-    mode: Annotated[
-        Optional[Literal["public", "private"]],
-        PydanticField(
-            default=None,
-            description="Mode of the agent, public or private",
-            json_schema_extra={
-                "x-group": "basic",
-            },
-        ),
-    ]
-    fee_percentage: Annotated[
-        Optional[Decimal],
-        PydanticField(
-            default=None,
-            description="Fee percentage of the agent",
-            ge=Decimal("0.0"),
-            json_schema_extra={
-                "x-group": "basic",
-            },
-        ),
-    ]
     purpose: Annotated[
         Optional[str],
         PydanticField(
@@ -584,38 +484,6 @@ class AgentUpdate(BaseModel):
             },
         ),
     ]
-    owner: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Owner identifier of the agent, used for access control",
-            max_length=50,
-            json_schema_extra={
-                "x-group": "internal",
-            },
-        ),
-    ]
-    upstream_id: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="External reference ID for idempotent operations",
-            max_length=100,
-            json_schema_extra={
-                "x-group": "internal",
-            },
-        ),
-    ]
-    upstream_extra: Annotated[
-        Optional[Dict[str, Any]],
-        PydanticField(
-            default=None,
-            description="Additional data store for upstream use",
-            json_schema_extra={
-                "x-group": "internal",
-            },
-        ),
-    ]
     # AI part
     model: Annotated[
         str,
@@ -675,91 +543,21 @@ class AgentUpdate(BaseModel):
             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],
-        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",
-            },
-        ),
-    ]
-    short_term_memory_strategy: Annotated[
-        Optional[Literal["trim", "summarize"]],
-        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]],
-        PydanticField(
-            default=None,
-            description=(
-                "Autonomous agent configurations.\n"
-                "autonomous:\n"
-                "  - id: a\n"
-                "    name: TestA\n"
-                "    minutes: 1\n"
-                "    prompt: |-\n"
-                "      Say hello [sequence], use number for sequence.\n"
-                "  - id: b\n"
-                "    name: TestB\n"
-                '    cron: "0/3 * * * *"\n'
-                "    prompt: |-\n"
-                "      Say hi [sequence], use number for sequence.\n"
-            ),
-            json_schema_extra={
-                "x-group": "autonomous",
-                "x-inline": True,
-            },
-        ),
-    ]
-    example_intro: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Introduction of the example",
-            max_length=2000,
-            json_schema_extra={
-                "x-group": "examples",
-            },
-        ),
-    ]
-    examples: Annotated[
-        Optional[List[AgentExample]],
-        PydanticField(
-            default=None,
-            description="List of example prompts for the agent",
-            max_length=6,
+            le=2.0,
             json_schema_extra={
-                "x-group": "examples",
-                "x-inline": True,
+                "x-group": "ai",
             },
         ),
     ]
-    # skills
-    skills: Annotated[
-        Optional[Dict[str, Any]],
+    presence_penalty: Annotated[
+        Optional[float],
         PydanticField(
-            default=None,
-            description="Dict of skills and their corresponding configurations",
+            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": "skills",
-                "x-inline": True,
+                "x-group": "ai",
             },
         ),
     ]
@@ -804,26 +602,80 @@ class AgentUpdate(BaseModel):
             },
         ),
     ]
-    cdp_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",
-            ]
-        ],
+    skills: Annotated[
+        Optional[Dict[str, Any]],
         PydanticField(
-            default="base-mainnet",
-            description="Network identifier for CDP integration",
+            default=None,
+            description="Dict of skills and their corresponding configurations",
+            json_schema_extra={
+                "x-group": "skills",
+                "x-inline": True,
+            },
+        ),
+    ]
+
+    def hash(self) -> str:
+        """
+        Generate a fixed-length hash based on the agent's content.
+
+        The hash remains unchanged if the content is the same and changes if the content changes.
+        This method serializes only AgentCore fields to JSON and generates a SHA-256 hash.
+        When called from subclasses, it will only use AgentCore fields, not subclass fields.
+
+        Returns:
+            str: A 64-character hexadecimal hash string
+        """
+        # Create a dictionary with only AgentCore fields for hashing
+        hash_data = {}
+
+        # Get only AgentCore field values, excluding None values for consistency
+        for field_name in AgentCore.model_fields:
+            value = getattr(self, field_name)
+            if value is not None:
+                hash_data[field_name] = value
+
+        # Convert to JSON string with sorted keys for consistent ordering
+        json_str = json.dumps(hash_data, sort_keys=True, default=str, ensure_ascii=True)
+
+        # Generate SHA-256 hash
+        return hashlib.sha256(json_str.encode("utf-8")).hexdigest()
+
+
+class AgentUserInput(AgentCore):
+    """Agent update model."""
+
+    short_term_memory_strategy: Annotated[
+        Optional[Literal["trim", "summarize"]],
+        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]],
+        PydanticField(
+            default=None,
+            description=(
+                "Autonomous agent configurations.\n"
+                "autonomous:\n"
+                "  - id: a\n"
+                "    name: TestA\n"
+                "    minutes: 1\n"
+                "    prompt: |-\n"
+                "      Say hello [sequence], use number for sequence.\n"
+                "  - id: b\n"
+                "    name: TestB\n"
+                '    cron: "0/3 * * * *"\n'
+                "    prompt: |-\n"
+                "      Say hi [sequence], use number for sequence.\n"
+            ),
             json_schema_extra={
-                "x-group": "deprecated",
+                "x-group": "autonomous",
+                "x-inline": True,
             },
         ),
     ]
@@ -871,6 +723,37 @@ class AgentUpdate(BaseModel):
         ),
     ]
 
+
+class AgentUpdate(AgentUserInput):
+    """Agent update model."""
+
+    model_config = ConfigDict(
+        title="Agent",
+        from_attributes=True,
+        json_schema_extra={
+            "required": ["name"],
+        },
+    )
+
+    upstream_id: Annotated[
+        Optional[str],
+        PydanticField(
+            default=None,
+            description="External reference ID for idempotent operations",
+            max_length=100,
+        ),
+    ]
+    upstream_extra: Annotated[
+        Optional[Dict[str, Any]],
+        PydanticField(
+            default=None,
+            description="Additional data store for upstream use",
+            json_schema_extra={
+                "x-group": "internal",
+            },
+        ),
+    ]
+
     @field_validator("purpose", "personality", "principles", "prompt", "prompt_append")
     @classmethod
     def validate_no_level1_level2_headings(cls, v: Optional[str]) -> Optional[str]:
@@ -960,6 +843,7 @@ class AgentUpdate(BaseModel):
                         detail="The shortest execution interval is 5 minutes",
                     )
 
+    # deprecated, use override instead
     async def update(self, id: str) -> "Agent":
         # Validate autonomous schedule settings if present
         if "autonomous" in self.model_dump(exclude_unset=True):
@@ -969,12 +853,6 @@ class AgentUpdate(BaseModel):
             db_agent = await db.get(AgentTable, id)
             if not db_agent:
                 raise HTTPException(status_code=404, detail="Agent not found")
-            # check owner
-            if self.owner and db_agent.owner != self.owner:
-                raise HTTPException(
-                    status_code=403,
-                    detail="You do not have permission to update this agent",
-                )
             # update
             for key, value in self.model_dump(exclude_unset=True).items():
                 setattr(db_agent, key, value)
@@ -991,15 +869,11 @@ class AgentUpdate(BaseModel):
             db_agent = await db.get(AgentTable, id)
             if not db_agent:
                 raise HTTPException(status_code=404, detail="Agent not found")
-            # check owner
-            if db_agent.owner and db_agent.owner != self.owner:
-                raise HTTPException(
-                    status_code=403,
-                    detail="You do not have permission to update this agent",
-                )
             # update
             for key, value in self.model_dump().items():
                 setattr(db_agent, key, value)
+            # version
+            db_agent.version = self.hash()
             await db.commit()
             await db.refresh(db_agent)
             return Agent.model_validate(db_agent)
@@ -1018,77 +892,195 @@ class AgentCreate(AgentUpdate):
             max_length=67,
         ),
     ]
+    owner: Annotated[
+        Optional[str],
+        PydanticField(
+            default=None,
+            description="Owner identifier of the agent, used for access control",
+            max_length=50,
+        ),
+    ]
+
+    async def check_upstream_id(self) -> None:
+        if not self.upstream_id:
+            return None
+        async with get_session() as db:
+            existing = await db.scalar(
+                select(AgentTable).where(AgentTable.upstream_id == self.upstream_id)
+            )
+            if existing:
+                raise HTTPException(
+                    status_code=400,
+                    detail="Upstream id already in use",
+                )
+
+    async def get_by_upstream_id(self) -> Optional["Agent"]:
+        if not self.upstream_id:
+            return None
+        async with get_session() as db:
+            existing = await db.scalar(
+                select(AgentTable).where(AgentTable.upstream_id == self.upstream_id)
+            )
+            if existing:
+                return Agent.model_validate(existing)
+            return None
+
+    async def create(self) -> "Agent":
+        # Validate autonomous schedule settings if present
+        if self.autonomous:
+            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)
+
+
+class AgentPublicInfo(BaseModel):
+    """Public information of the agent."""
+
+    description: Annotated[
+        Optional[str],
+        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],
+        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],
+        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],
+        PydanticField(
+            default=None,
+            description="Token address of the agent",
+            max_length=42,
+            json_schema_extra={
+                "x-group": "internal",
+                "readOnly": True,
+            },
+        ),
+    ]
+    token_pool: Annotated[
+        Optional[str],
+        PydanticField(
+            default=None,
+            description="Pool of the agent token",
+            max_length=42,
+            json_schema_extra={
+                "x-group": "internal",
+                "readOnly": True,
+            },
+        ),
+    ]
+    fee_percentage: Annotated[
+        Optional[Decimal],
+        PydanticField(
+            default=None,
+            description="Fee percentage of the agent",
+            ge=Decimal("0.0"),
+            json_schema_extra={
+                "x-group": "basic",
+            },
+        ),
+    ]
+    example_intro: Annotated[
+        Optional[str],
+        PydanticField(
+            default=None,
+            description="Introduction of the example",
+            max_length=2000,
+            json_schema_extra={
+                "x-group": "examples",
+            },
+        ),
+    ]
+    examples: Annotated[
+        Optional[List[AgentExample]],
+        PydanticField(
+            default=None,
+            description="List of example prompts for the agent",
+            max_length=6,
+            json_schema_extra={
+                "x-group": "examples",
+                "x-inline": True,
+            },
+        ),
+    ]
 
-    async def check_upstream_id(self) -> None:
-        if not self.upstream_id:
-            return None
-        async with get_session() as db:
-            existing = await db.scalar(
-                select(AgentTable).where(AgentTable.upstream_id == self.upstream_id)
-            )
-            if existing:
-                raise HTTPException(
-                    status_code=400,
-                    detail="Upstream id already in use",
-                )
-
-    async def get_by_upstream_id(self) -> Optional["Agent"]:
-        if not self.upstream_id:
-            return None
-        async with get_session() as db:
-            existing = await db.scalar(
-                select(AgentTable).where(AgentTable.upstream_id == self.upstream_id)
-            )
-            if existing:
-                return Agent.model_validate(existing)
-            return None
-
-    async def create(self) -> "Agent":
-        # Validate autonomous schedule settings if present
-        if self.autonomous:
-            self.validate_autonomous_schedule()
-
-        async with get_session() as db:
-            db_agent = AgentTable(**self.model_dump())
-            db.add(db_agent)
-            await db.commit()
-            await db.refresh(db_agent)
-            return Agent.model_validate(db_agent)
-
-    async def create_or_update(self) -> ("Agent", bool):
-        # Validation is now handled by field validators
-        await self.check_upstream_id()
-
-        # Validate autonomous schedule settings if present
-        if self.autonomous:
-            self.validate_autonomous_schedule()
-
-        is_new = False
-        async with get_session() as db:
-            db_agent = await db.get(AgentTable, self.id)
-            if not db_agent:
-                db_agent = AgentTable(**self.model_dump())
-                db.add(db_agent)
-                is_new = True
-            else:
-                # check owner
-                if self.owner and db_agent.owner != self.owner:
-                    raise HTTPException(
-                        status_code=403,
-                        detail="You do not have permission to update this agent",
-                    )
-                for key, value in self.model_dump(exclude_unset=True).items():
-                    setattr(db_agent, key, value)
-            await db.commit()
-            await db.refresh(db_agent)
-            return Agent.model_validate(db_agent), is_new
-
 
-class Agent(AgentCreate):
+class Agent(AgentCreate, AgentPublicInfo):
     """Agent model."""
 
     model_config = ConfigDict(from_attributes=True)
 
+    slug: Annotated[
+        Optional[str],
+        PydanticField(
+            default=None,
+            description="Slug of the agent, used for URL generation",
+            max_length=20,
+            min_length=2,
+        ),
+    ]
+    version: Annotated[
+        Optional[str],
+        PydanticField(
+            default=None,
+            description="Version hash of the agent",
+        ),
+    ]
+    statistics: Annotated[
+        Optional[Dict[str, Any]],
+        PydanticField(
+            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"),
+    ]
+    account_snapshot: Annotated[
+        Optional[CreditAccount],
+        PydanticField(
+            description="Account snapshot of the agent, update every 1 hour for query"
+        ),
+    ]
+    extra: Annotated[
+        Optional[Dict[str, Any]],
+        PydanticField(
+            description="Other helper data fields for query, come from agent and agent data"
+        ),
+    ]
     # auto timestamp
     created_at: Annotated[
         datetime,
@@ -1469,7 +1461,7 @@ class Agent(AgentCreate):
             return schema
 
 
-class AgentResponse(BaseModel):
+class AgentResponse(Agent):
     """Response model for Agent API."""
 
     model_config = ConfigDict(
@@ -1479,193 +1471,6 @@ class AgentResponse(BaseModel):
         },
     )
 
-    id: Annotated[
-        str,
-        PydanticField(
-            description="Unique identifier for the agent. Must be URL-safe, containing only lowercase letters, numbers, and hyphens",
-        ),
-    ]
-    # auto timestamp
-    created_at: Annotated[
-        datetime,
-        PydanticField(
-            description="Timestamp when the agent was created, will ignore when importing"
-        ),
-    ]
-    updated_at: Annotated[
-        datetime,
-        PydanticField(
-            description="Timestamp when the agent was last updated, will ignore when importing"
-        ),
-    ]
-    # Agent part
-    name: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Display name of the agent",
-        ),
-    ]
-    slug: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Slug of the agent, used for URL generation",
-        ),
-    ]
-    description: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Description of the agent, for public view, not contained in prompt",
-        ),
-    ]
-    external_website: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Link of external website of the agent, if you have one",
-        ),
-    ]
-    picture: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Picture of the agent",
-        ),
-    ]
-    ticker: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Ticker symbol of the agent",
-        ),
-    ]
-    token_address: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Token address of the agent",
-        ),
-    ]
-    token_pool: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Pool of the agent token",
-        ),
-    ]
-    mode: Annotated[
-        Optional[Literal["public", "private"]],
-        PydanticField(
-            default=None,
-            description="Mode of the agent, public or private",
-        ),
-    ]
-    fee_percentage: Annotated[
-        Optional[Decimal],
-        PydanticField(
-            default=None,
-            description="Fee percentage of the agent",
-        ),
-    ]
-    owner: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Owner identifier of the agent, used for access control",
-            max_length=50,
-            json_schema_extra={
-                "x-group": "internal",
-            },
-        ),
-    ]
-    upstream_id: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="External reference ID for idempotent operations",
-            max_length=100,
-            json_schema_extra={
-                "x-group": "internal",
-            },
-        ),
-    ]
-    upstream_extra: Annotated[
-        Optional[Dict[str, Any]],
-        PydanticField(
-            default=None,
-            description="Additional data store for upstream use",
-        ),
-    ]
-    # AI part
-    model: Annotated[
-        str,
-        PydanticField(
-            description="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, reigent",
-        ),
-    ]
-    # autonomous mode
-    autonomous: Annotated[
-        Optional[List[Dict[str, Any]]],
-        PydanticField(
-            default=None,
-            description=("Autonomous agent configurations."),
-        ),
-    ]
-    # agent examples
-    example_intro: Annotated[
-        Optional[str],
-        PydanticField(
-            default=None,
-            description="Introduction for example interactions",
-        ),
-    ]
-    examples: Annotated[
-        Optional[List[AgentExample]],
-        PydanticField(
-            default=None,
-            description="List of example prompts for the agent",
-        ),
-    ]
-    # skills
-    skills: Annotated[
-        Optional[Dict[str, Any]],
-        PydanticField(
-            default=None,
-            description="Dict of skills and their corresponding configurations",
-        ),
-    ]
-    wallet_provider: Annotated[
-        Optional[Literal["cdp", "readonly"]],
-        PydanticField(
-            default="cdp",
-            description="Provider of the agent's wallet",
-        ),
-    ]
-    network_id: Annotated[
-        Optional[str],
-        PydanticField(
-            default="base-mainnet",
-            description="Network identifier",
-        ),
-    ]
-    cdp_network_id: Annotated[
-        Optional[str],
-        PydanticField(
-            default="base-mainnet",
-            description="Network identifier for CDP integration",
-        ),
-    ]
-    # telegram entrypoint
-    telegram_entrypoint_enabled: Annotated[
-        Optional[bool],
-        PydanticField(
-            default=False,
-            description="Whether the agent can play telegram bot",
-        ),
-    ]
-
     # data part
     cdp_wallet_address: Annotated[
         Optional[str], PydanticField(description="CDP wallet address for the agent")
@@ -1753,6 +1558,18 @@ class AgentResponse(BaseModel):
         # 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 = []
@@ -1852,4 +1669,4 @@ class AgentResponse(BaseModel):
             }
         )
 
-        return cls.model_validate(data)
+        return cls.model_construct(**data)