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

intentkit/core/engine.py

@@ -17,11 +17,10 @@ import textwrap
 import time
 import traceback
 from datetime import datetime
-from typing import Optional
 
 import sqlalchemy
 from epyxid import XID
-from fastapi import HTTPException
+from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import (
     BaseMessage,
     HumanMessage,
@@ -30,21 +29,22 @@ from langchain_core.tools import BaseTool
 from langgraph.errors import GraphRecursionError
 from langgraph.graph.state import CompiledStateGraph
 from langgraph.prebuilt import create_react_agent
+from langgraph.runtime import Runtime
 from sqlalchemy import func, update
 from sqlalchemy.exc import SQLAlchemyError
 
 from intentkit.abstracts.graph import AgentContext, AgentError, AgentState
 from intentkit.config.config import config
+from intentkit.core.chat import clear_thread_memory
 from intentkit.core.credit import expense_message, expense_skill
 from intentkit.core.node import PreModelNode, post_model_node
 from intentkit.core.prompt import (
     create_formatted_prompt_function,
     explain_prompt,
 )
-from intentkit.core.skill import skill_store
 from intentkit.models.agent import Agent, AgentTable
 from intentkit.models.agent_data import AgentData, AgentQuota
-from intentkit.models.app_setting import AppSetting
+from intentkit.models.app_setting import AppSetting, SystemMessageType
 from intentkit.models.chat import (
     AuthorType,
     ChatMessage,
@@ -53,27 +53,24 @@ from intentkit.models.chat import (
 )
 from intentkit.models.credit import CreditAccount, OwnerType
 from intentkit.models.db import get_langgraph_checkpointer, get_session
-from intentkit.models.llm import LLMModelInfo, LLMProvider
-from intentkit.models.skill import AgentSkillData, ThreadSkillData
+from intentkit.models.llm import LLMModelInfo, LLMProvider, create_llm_model
+from intentkit.models.skill import AgentSkillData, ChatSkillData, Skill
 from intentkit.models.user import User
 from intentkit.utils.error import IntentKitAPIError
 
 logger = logging.getLogger(__name__)
 
-
 # Global variable to cache all agent executors
 _agents: dict[str, CompiledStateGraph] = {}
-_private_agents: dict[str, CompiledStateGraph] = {}
 
 # Global dictionaries to cache agent update times
 _agents_updated: dict[str, datetime] = {}
-_private_agents_updated: dict[str, datetime] = {}
 
 
-async def create_agent(
-    agent: Agent, is_private: bool = False, has_search: bool = False
+async def build_agent(
+    agent: Agent, agent_data: AgentData, custom_skills: list[BaseTool] = []
 ) -> CompiledStateGraph:
-    """Create an AI agent with specified configuration and tools.
+    """Build an AI agent with specified configuration and tools.
 
     This function:
     1. Initializes LLM with specified model
@@ -83,16 +80,13 @@ async def create_agent(
 
     Args:
         agent (Agent): Agent configuration object
-        is_private (bool, optional): Flag indicating whether the agent is private. Defaults to False.
-        has_search (bool, optional): Flag indicating whether to include search tools. Defaults to False.
+        agent_data (AgentData): Agent data object
+        custom_skills (list[BaseTool], optional): Designed for advanced user who directly
+            call this function to inject custom skills into the agent tool node.
 
     Returns:
         CompiledStateGraph: Initialized LangChain agent
     """
-    agent_data = await AgentData.get(agent.id)
-
-    # ==== Initialize LLM using the LLM abstraction.
-    from intentkit.models.llm import create_llm_model
 
     # Create the LLM model instance
     llm_model = await create_llm_model(
@@ -102,17 +96,12 @@ async def create_agent(
         presence_penalty=agent.presence_penalty,
     )
 
-    # Get the LLM instance
-    llm = await llm_model.create_instance(config)
-
-    # Get the token limit from the model info
-    input_token_limit = min(config.input_token_limit, llm_model.info.context_length)
-
     # ==== Store buffered conversation history in memory.
     memory = get_langgraph_checkpointer()
 
     # ==== Load skills
     tools: list[BaseTool | dict] = []
+    private_tools: list[BaseTool | dict] = []
 
     if agent.skills:
         for k, v in agent.skills.items():
@@ -121,50 +110,75 @@ async def create_agent(
             try:
                 skill_module = importlib.import_module(f"intentkit.skills.{k}")
                 if hasattr(skill_module, "get_skills"):
+                    # all
                     skill_tools = await skill_module.get_skills(
-                        v, is_private, skill_store, agent_id=agent.id
+                        v, False, agent_id=agent.id, agent=agent
                     )
                     if skill_tools and len(skill_tools) > 0:
                         tools.extend(skill_tools)
+                    # private
+                    skill_private_tools = await skill_module.get_skills(
+                        v, True, agent_id=agent.id, agent=agent
+                    )
+                    if skill_private_tools and len(skill_private_tools) > 0:
+                        private_tools.extend(skill_private_tools)
                 else:
                     logger.error(f"Skill {k} does not have get_skills function")
             except ImportError as e:
                 logger.error(f"Could not import skill module: {k} ({e})")
 
+    # add custom skills to private tools
+    if custom_skills and len(custom_skills) > 0:
+        private_tools.extend(custom_skills)
+
     # filter the duplicate tools
     tools = list({tool.name: tool for tool in tools}.values())
-
-    # Add search tools if requested
-    if (
-        has_search
-        and llm_model.info.provider == LLMProvider.OPENAI
-        and llm_model.info.supports_search
-        and not agent.model.startswith(
-            "gpt-5"
-        )  # tmp disable gpt-5 search since package bugs
-    ):
-        tools.append({"type": "web_search_preview"})
+    private_tools = list({tool.name: tool for tool in private_tools}.values())
 
     # Create the formatted_prompt function using the refactored prompt module
     formatted_prompt = create_formatted_prompt_function(agent, agent_data)
 
-    for tool in tools:
+    # bind tools to llm
+    async def select_model(
+        state: AgentState, runtime: Runtime[AgentContext]
+    ) -> BaseChatModel:
+        llm_params = {}
+        context = runtime.context
+        if context.search:
+            if llm_model.info.supports_search:
+                if llm_model.info.provider == LLMProvider.OPENAI:
+                    tools.append({"type": "web_search"})
+                    private_tools.append({"type": "web_search"})
+                    if agent.model.startswith("gpt-5-"):
+                        llm_params["reasoning_effort"] = "low"
+                if llm_model.info.provider == LLMProvider.XAI:
+                    llm_params["search_parameters"] = {"mode": "auto"}
+            # TODO: else use a search skill
+        # build llm now
+        llm = await llm_model.create_instance(llm_params)
+        if context.is_private:
+            return llm.bind_tools(private_tools)
+        return llm.bind_tools(tools)
+
+    for tool in private_tools:
         logger.info(
-            f"[{agent.id}{'-private' if is_private else ''}] loaded tool: {tool.name if isinstance(tool, BaseTool) else tool}"
+            f"[{agent.id}] loaded tool: {tool.name if isinstance(tool, BaseTool) else tool}"
         )
 
     # Pre model hook
+    summarize_llm = await create_llm_model(model_name="gpt-5-mini")
+    summarize_model = await summarize_llm.create_instance()
     pre_model_hook = PreModelNode(
-        model=llm,
+        model=summarize_model,
         short_term_memory_strategy=agent.short_term_memory_strategy,
-        max_tokens=input_token_limit // 2,
-        max_summary_tokens=2048,  # later we can let agent to set this
+        max_tokens=llm_model.info.context_length // 2,
+        max_summary_tokens=2048,
     )
 
     # Create ReAct Agent using the LLM and CDP Agentkit tools.
     executor = create_react_agent(
-        model=llm,
-        tools=tools,
+        model=select_model,
+        tools=private_tools,
         prompt=formatted_prompt,
         pre_model_hook=pre_model_hook,
         post_model_hook=post_model_node if config.payment_enabled else None,
@@ -178,7 +192,23 @@ async def create_agent(
     return executor
 
 
-async def initialize_agent(aid, is_private=False):
+async def create_agent(agent: Agent) -> CompiledStateGraph:
+    """Create an AI agent with specified configuration and tools.
+
+    This function maintains backward compatibility by calling build_agent internally.
+
+    Args:
+        agent (Agent): Agent configuration object
+        is_private (bool, optional): Flag indicating whether the agent is private. Defaults to False.
+
+    Returns:
+        CompiledStateGraph: Initialized LangChain agent
+    """
+    agent_data = await AgentData.get(agent.id)
+    return await build_agent(agent, agent_data)
+
+
+async def initialize_agent(aid):
     """Initialize an AI agent with specified configuration and tools.
 
     This function:
@@ -197,63 +227,41 @@ async def initialize_agent(aid, is_private=False):
         HTTPException: If agent not found (404) or database error (500)
     """
     # get the agent from the database
-    agent: Optional[Agent] = await Agent.get(aid)
+    agent: Agent | None = await Agent.get(aid)
     if not agent:
-        raise HTTPException(status_code=404, detail="Agent not found")
-
-    # Determine if search should be enabled based on model capabilities
-    from intentkit.models.llm import create_llm_model
-
-    llm_model = await create_llm_model(
-        model_name=agent.model,
-        temperature=agent.temperature,
-        frequency_penalty=agent.frequency_penalty,
-        presence_penalty=agent.presence_penalty,
-    )
-    has_search = (
-        llm_model.info.provider == LLMProvider.OPENAI and llm_model.info.supports_search
-    )
+        raise IntentKitAPIError(
+            status_code=404, key="AgentNotFound", message="Agent not found"
+        )
 
     # Create the agent using the new create_agent function
-    executor = await create_agent(agent, is_private, has_search)
+    executor = await create_agent(agent)
 
     # Cache the agent executor
-    if is_private:
-        _private_agents[aid] = executor
-        _private_agents_updated[aid] = agent.updated_at
-    else:
-        _agents[aid] = executor
-        _agents_updated[aid] = agent.updated_at
+    _agents[aid] = executor
+    _agents_updated[aid] = agent.deployed_at if agent.deployed_at else agent.updated_at
 
 
-async def agent_executor(
-    agent_id: str, is_private: bool
-) -> (CompiledStateGraph, float):
+async def agent_executor(agent_id: str) -> tuple[CompiledStateGraph, float]:
     start = time.perf_counter()
     agent = await Agent.get(agent_id)
     if not agent:
-        raise HTTPException(status_code=404, detail="Agent not found")
-    agents = _private_agents if is_private else _agents
-    agents_updated = _private_agents_updated if is_private else _agents_updated
-
+        raise IntentKitAPIError(
+            status_code=404, key="AgentNotFound", message="Agent not found"
+        )
+    updated_at = agent.deployed_at if agent.deployed_at else agent.updated_at
     # Check if agent needs reinitialization due to updates
     needs_reinit = False
-    if agent_id in agents:
-        if (
-            agent_id not in agents_updated
-            or agent.updated_at != agents_updated[agent_id]
-        ):
+    if agent_id in _agents:
+        if agent_id not in _agents_updated or updated_at != _agents_updated[agent_id]:
             needs_reinit = True
-            logger.info(
-                f"Reinitializing agent {agent_id} due to updates, private mode: {is_private}"
-            )
+            logger.info(f"Reinitializing agent {agent_id} due to updates")
 
     # cold start or needs reinitialization
     cold_start_cost = 0.0
-    if (agent_id not in agents) or needs_reinit:
-        await initialize_agent(agent_id, is_private)
+    if (agent_id not in _agents) or needs_reinit:
+        await initialize_agent(agent_id)
         cold_start_cost = time.perf_counter() - start
-    return agents[agent_id], cold_start_cost
+    return _agents[agent_id], cold_start_cost
 
 
 async def stream_agent(message: ChatMessageCreate):
@@ -272,24 +280,62 @@ async def stream_agent(message: ChatMessageCreate):
     Yields:
         ChatMessage: Individual response messages including timing information
     """
+    agent = await Agent.get(message.agent_id)
+    executor, cold_start_cost = await agent_executor(message.agent_id)
+    message.cold_start_cost = cold_start_cost
+    async for chat_message in stream_agent_raw(message, agent, executor):
+        yield chat_message
+
+
+async def stream_agent_raw(
+    message: ChatMessageCreate, agent: Agent, executor: CompiledStateGraph
+):
     start = time.perf_counter()
     # make sure reply_to is set
     message.reply_to = message.id
 
     # save input message first
-    input = await message.save()
+    user_message = await message.save()
+
+    # temporary debug logging for telegram messages
+    if user_message.author_type == AuthorType.TELEGRAM:
+        logger.info(
+            f"[TELEGRAM DEBUG] Agent: {user_message.agent_id} | Chat: {user_message.chat_id} | Message: {user_message.message}"
+        )
 
-    # agent
-    agent = await Agent.get(input.agent_id)
+    if re.search(
+        r"(@clear|/clear)(?!\w)",
+        user_message.message.strip(),
+        re.IGNORECASE,
+    ):
+        await clear_thread_memory(user_message.agent_id, user_message.chat_id)
+
+        confirmation_message = ChatMessageCreate(
+            id=str(XID()),
+            agent_id=user_message.agent_id,
+            chat_id=user_message.chat_id,
+            user_id=user_message.user_id,
+            author_id=user_message.agent_id,
+            author_type=AuthorType.AGENT,
+            model=agent.model,
+            thread_type=user_message.author_type,
+            reply_to=user_message.id,
+            message="Memory in context has been cleared.",
+            time_cost=time.perf_counter() - start,
+        )
+
+        yield await confirmation_message.save()
+        return
 
-    # model
     model = await LLMModelInfo.get(agent.model)
 
     payment_enabled = config.payment_enabled
+    if user_message.author_type == AuthorType.X402:
+        payment_enabled = False
 
     # check user balance
     if payment_enabled:
-        if not input.user_id or not agent.owner:
+        if not user_message.user_id or not agent.owner:
             raise IntentKitAPIError(
                 500,
                 "PaymentError",
@@ -298,24 +344,22 @@ async def stream_agent(message: ChatMessageCreate):
         if agent.fee_percentage and agent.fee_percentage > 100:
             owner = await User.get(agent.owner)
             if owner and agent.fee_percentage > 100 + owner.nft_count * 10:
-                error_message_create = ChatMessageCreate(
-                    id=str(XID()),
-                    agent_id=input.agent_id,
-                    chat_id=input.chat_id,
-                    user_id=input.user_id,
-                    author_id=input.agent_id,
-                    author_type=AuthorType.SYSTEM,
-                    thread_type=input.author_type,
-                    reply_to=input.id,
-                    message="If you are the owner of this agent, please Update the Service Fee % to be in compliance with the Nation guidelines (Max 100% + 10% per Nation Pass NFT held)",
+                error_message_create = await ChatMessageCreate.from_system_message(
+                    SystemMessageType.SERVICE_FEE_ERROR,
+                    agent_id=user_message.agent_id,
+                    chat_id=user_message.chat_id,
+                    user_id=user_message.user_id,
+                    author_id=user_message.agent_id,
+                    thread_type=user_message.author_type,
+                    reply_to=user_message.id,
                     time_cost=time.perf_counter() - start,
                 )
                 error_message = await error_message_create.save()
                 yield error_message
                 return
         # payer
-        payer = input.user_id
-        if input.author_type in [
+        payer = user_message.user_id
+        if user_message.author_type in [
             AuthorType.TELEGRAM,
             AuthorType.TWITTER,
             AuthorType.API,
@@ -336,16 +380,14 @@ async def stream_agent(message: ChatMessageCreate):
             abuse_check = False
         if abuse_check and payer != agent.owner and user_account.free_credits > 0:
             if quota and quota.free_income_daily > 24000:
-                error_message_create = ChatMessageCreate(
-                    id=str(XID()),
-                    agent_id=input.agent_id,
-                    chat_id=input.chat_id,
-                    user_id=input.user_id,
-                    author_id=input.agent_id,
-                    author_type=AuthorType.SYSTEM,
-                    thread_type=input.author_type,
-                    reply_to=input.id,
-                    message="This Agent has reached its free CAP income limit for today! Start using paid CAPs or wait until this limit expires in less than 24 hours.",
+                error_message_create = await ChatMessageCreate.from_system_message(
+                    SystemMessageType.DAILY_USAGE_LIMIT_EXCEEDED,
+                    agent_id=user_message.agent_id,
+                    chat_id=user_message.chat_id,
+                    user_id=user_message.user_id,
+                    author_id=user_message.agent_id,
+                    thread_type=user_message.author_type,
+                    reply_to=user_message.id,
                     time_cost=time.perf_counter() - start,
                 )
                 error_message = await error_message_create.save()
@@ -356,16 +398,14 @@ async def stream_agent(message: ChatMessageCreate):
         if quota and quota.avg_action_cost > 0:
             avg_count = quota.avg_action_cost
         if not user_account.has_sufficient_credits(avg_count):
-            error_message_create = ChatMessageCreate(
-                id=str(XID()),
-                agent_id=input.agent_id,
-                chat_id=input.chat_id,
-                user_id=input.user_id,
-                author_id=input.agent_id,
-                author_type=AuthorType.SYSTEM,
-                thread_type=input.author_type,
-                reply_to=input.id,
-                message="Insufficient balance.",
+            error_message_create = await ChatMessageCreate.from_system_message(
+                SystemMessageType.INSUFFICIENT_BALANCE,
+                agent_id=user_message.agent_id,
+                chat_id=user_message.chat_id,
+                user_id=user_message.user_id,
+                author_id=user_message.agent_id,
+                thread_type=user_message.author_type,
+                reply_to=user_message.id,
                 time_cost=time.perf_counter() - start,
             )
             error_message = await error_message_create.save()
@@ -373,26 +413,22 @@ async def stream_agent(message: ChatMessageCreate):
             return
 
     is_private = False
-    if input.user_id == agent.owner:
+    if user_message.user_id == agent.owner:
         is_private = True
 
-    executor, cold_start_cost = await agent_executor(input.agent_id, is_private)
-    last = start + cold_start_cost
+    last = start
 
     # Extract images from attachments
     image_urls = []
-    if input.attachments:
+    if user_message.attachments:
         image_urls = [
             att["url"]
-            for att in input.attachments
+            for att in user_message.attachments
             if "type" in att and att["type"] == "image" and "url" in att
         ]
 
     # Process input message to handle @skill patterns
-    if config.admin_llm_skill_control:
-        input_message = await explain_prompt(input.message)
-    else:
-        input_message = input.message
+    input_message = await explain_prompt(user_message.message)
 
     # super mode
     recursion_limit = 30
@@ -402,9 +438,11 @@ async def stream_agent(message: ChatMessageCreate):
         input_message = re.sub(r"\b@super\b", "", input_message).strip()
 
     # llm native search
+    search = False
     if re.search(r"\b@search\b", input_message) or re.search(
         r"\b@web\b", input_message
     ):
+        search = True
         if model.supports_search:
             input_message = re.sub(
                 r"\b@search\b",
@@ -421,8 +459,8 @@ async def stream_agent(message: ChatMessageCreate):
             input_message = re.sub(r"\b@web\b", "", input_message).strip()
 
     # content to llm
-    content = [
-        {"type": "text", "text": input_message},
+    messages = [
+        HumanMessage(content=input_message),
     ]
     # if the model doesn't natively support image parsing, add the image URLs to the message
     if image_urls:
@@ -430,25 +468,24 @@ async def stream_agent(message: ChatMessageCreate):
             agent.has_image_parser_skill(is_private=is_private)
             and not model.supports_image_input
         ):
-            input_message += f"\n\nImages:\n{'\n'.join(image_urls)}"
-            content = [
-                {"type": "text", "text": input_message},
+            image_urls_text = "\n".join(image_urls)
+            input_message += f"\n\nImages:\n{image_urls_text}"
+            messages = [
+                HumanMessage(content=input_message),
             ]
         else:
             # anyway, pass it directly to LLM
-            content.extend(
+            messages.extend(
                 [
-                    {"type": "image_url", "image_url": {"url": image_url}}
+                    HumanMessage(
+                        content={"type": "image_url", "image_url": {"url": image_url}}
+                    )
                     for image_url in image_urls
                 ]
             )
 
-    messages = [
-        HumanMessage(content=content),
-    ]
-
     # stream config
-    thread_id = f"{input.agent_id}-{input.chat_id}"
+    thread_id = f"{user_message.agent_id}-{user_message.chat_id}"
     stream_config = {
         "configurable": {
             "thread_id": thread_id,
@@ -456,13 +493,18 @@ async def stream_agent(message: ChatMessageCreate):
         "recursion_limit": recursion_limit,
     }
 
+    def get_agent() -> Agent:
+        return agent
+
     context = AgentContext(
-        agent_id=input.agent_id,
-        chat_id=input.chat_id,
-        user_id=input.user_id,
-        app_id=input.app_id,
-        entrypoint=input.author_type,
+        agent_id=user_message.agent_id,
+        get_agent=get_agent,
+        chat_id=user_message.chat_id,
+        user_id=user_message.user_id,
+        app_id=user_message.app_id,
+        entrypoint=user_message.author_type,
         is_private=is_private,
+        search=search,
         payer=payer if payment_enabled else None,
     )
 
@@ -498,14 +540,14 @@ async def stream_agent(message: ChatMessageCreate):
                     # agent message
                     chat_message_create = ChatMessageCreate(
                         id=str(XID()),
-                        agent_id=input.agent_id,
-                        chat_id=input.chat_id,
-                        user_id=input.user_id,
-                        author_id=input.agent_id,
+                        agent_id=user_message.agent_id,
+                        chat_id=user_message.chat_id,
+                        user_id=user_message.user_id,
+                        author_id=user_message.agent_id,
                         author_type=AuthorType.AGENT,
                         model=agent.model,
-                        thread_type=input.author_type,
-                        reply_to=input.id,
+                        thread_type=user_message.author_type,
+                        reply_to=user_message.id,
                         message=content,
                         input_tokens=(
                             msg.usage_metadata.get("input_tokens", 0)
@@ -520,9 +562,6 @@ async def stream_agent(message: ChatMessageCreate):
                         time_cost=this_time - last,
                     )
                     last = this_time
-                    if cold_start_cost > 0:
-                        chat_message_create.cold_start_cost = cold_start_cost
-                        cold_start_cost = 0
                     # handle message and payment in one transaction
                     async with get_session() as session:
                         # payment
@@ -543,7 +582,7 @@ async def stream_agent(message: ChatMessageCreate):
                                 for tool_output in tool_outputs:
                                     if tool_output.get("type") == "web_search_call":
                                         logger.info(
-                                            f"[{input.agent_id}] Found web_search_call in additional_kwargs"
+                                            f"[{user_message.agent_id}] Found web_search_call in additional_kwargs"
                                         )
                                         amount += 35
                                         break
@@ -551,11 +590,13 @@ async def stream_agent(message: ChatMessageCreate):
                                 session,
                                 payer,
                                 chat_message_create.id,
-                                input.id,
+                                user_message.id,
                                 amount,
                                 agent,
                             )
-                            logger.info(f"[{input.agent_id}] expense message: {amount}")
+                            logger.info(
+                                f"[{user_message.agent_id}] expense message: {amount}"
+                            )
                             chat_message_create.credit_event_id = credit_event.id
                             chat_message_create.credit_cost = credit_event.total_amount
                         chat_message = await chat_message_create.save_in_session(
@@ -606,14 +647,14 @@ async def stream_agent(message: ChatMessageCreate):
                             break
                 skill_message_create = ChatMessageCreate(
                     id=str(XID()),
-                    agent_id=input.agent_id,
-                    chat_id=input.chat_id,
-                    user_id=input.user_id,
-                    author_id=input.agent_id,
+                    agent_id=user_message.agent_id,
+                    chat_id=user_message.chat_id,
+                    user_id=user_message.user_id,
+                    author_id=user_message.agent_id,
                     author_type=AuthorType.SKILL,
                     model=agent.model,
-                    thread_type=input.author_type,
-                    reply_to=input.id,
+                    thread_type=user_message.author_type,
+                    reply_to=user_message.id,
                     message="",
                     skill_calls=skill_calls,
                     attachments=cached_attachments,
@@ -634,9 +675,6 @@ async def stream_agent(message: ChatMessageCreate):
                     time_cost=this_time - last,
                 )
                 last = this_time
-                if cold_start_cost > 0:
-                    skill_message_create.cold_start_cost = cold_start_cost
-                    cold_start_cost = 0
                 # save message and credit in one transaction
                 async with get_session() as session:
                     if payment_enabled:
@@ -650,7 +688,7 @@ async def stream_agent(message: ChatMessageCreate):
                                 session,
                                 payer,
                                 skill_message_create.id,
-                                input.id,
+                                user_message.id,
                                 message_amount,
                                 agent,
                             )
@@ -664,11 +702,14 @@ async def stream_agent(message: ChatMessageCreate):
                         for skill_call in skill_calls:
                             if not skill_call["success"]:
                                 continue
+                            skill = await Skill.get(skill_call["name"])
+                            if not skill:
+                                continue
                             payment_event = await expense_skill(
                                 session,
                                 payer,
                                 skill_message_create.id,
-                                input.id,
+                                user_message.id,
                                 skill_call["id"],
                                 skill_call["name"],
                                 agent,
@@ -676,7 +717,7 @@ async def stream_agent(message: ChatMessageCreate):
                             skill_call["credit_event_id"] = payment_event.id
                             skill_call["credit_cost"] = payment_event.total_amount
                             logger.info(
-                                f"[{input.agent_id}] skill payment: {skill_call}"
+                                f"[{user_message.agent_id}] skill payment: {skill_call}"
                             )
                     skill_message_create.skill_calls = skill_calls
                     skill_message = await skill_message_create.save_in_session(session)
@@ -702,38 +743,33 @@ async def stream_agent(message: ChatMessageCreate):
                                 content = msg.content[0]
                             post_model_message_create = ChatMessageCreate(
                                 id=str(XID()),
-                                agent_id=input.agent_id,
-                                chat_id=input.chat_id,
-                                user_id=input.user_id,
-                                author_id=input.agent_id,
+                                agent_id=user_message.agent_id,
+                                chat_id=user_message.chat_id,
+                                user_id=user_message.user_id,
+                                author_id=user_message.agent_id,
                                 author_type=AuthorType.AGENT,
                                 model=agent.model,
-                                thread_type=input.author_type,
-                                reply_to=input.id,
+                                thread_type=user_message.author_type,
+                                reply_to=user_message.id,
                                 message=content,
                                 input_tokens=0,
                                 output_tokens=0,
                                 time_cost=this_time - last,
                             )
                             last = this_time
-                            if cold_start_cost > 0:
-                                post_model_message_create.cold_start_cost = (
-                                    cold_start_cost
-                                )
-                                cold_start_cost = 0
                             post_model_message = await post_model_message_create.save()
                             yield post_model_message
-                        error_message_create = ChatMessageCreate(
-                            id=str(XID()),
-                            agent_id=input.agent_id,
-                            chat_id=input.chat_id,
-                            user_id=input.user_id,
-                            author_id=input.agent_id,
-                            author_type=AuthorType.SYSTEM,
-                            thread_type=input.author_type,
-                            reply_to=input.id,
-                            message="Insufficient balance.",
-                            time_cost=0,
+                        error_message_create = (
+                            await ChatMessageCreate.from_system_message(
+                                SystemMessageType.INSUFFICIENT_BALANCE,
+                                agent_id=user_message.agent_id,
+                                chat_id=user_message.chat_id,
+                                user_id=user_message.user_id,
+                                author_id=user_message.agent_id,
+                                thread_type=user_message.author_type,
+                                reply_to=user_message.id,
+                                time_cost=0,
+                            )
                         )
                         error_message = await error_message_create.save()
                         yield error_message
@@ -749,16 +785,14 @@ async def stream_agent(message: ChatMessageCreate):
             f"failed to execute agent: {str(e)}\n{error_traceback}",
             extra={"thread_id": thread_id},
         )
-        error_message_create = ChatMessageCreate(
-            id=str(XID()),
-            agent_id=input.agent_id,
-            chat_id=input.chat_id,
-            user_id=input.user_id,
-            author_id=input.agent_id,
-            author_type=AuthorType.SYSTEM,
-            thread_type=input.author_type,
-            reply_to=input.id,
-            message="Agent Internal Error",
+        error_message_create = await ChatMessageCreate.from_system_message(
+            SystemMessageType.AGENT_INTERNAL_ERROR,
+            agent_id=user_message.agent_id,
+            chat_id=user_message.chat_id,
+            user_id=user_message.user_id,
+            author_id=user_message.agent_id,
+            thread_type=user_message.author_type,
+            reply_to=user_message.id,
             time_cost=time.perf_counter() - start,
         )
         error_message = await error_message_create.save()
@@ -768,18 +802,16 @@ async def stream_agent(message: ChatMessageCreate):
         error_traceback = traceback.format_exc()
         logger.error(
             f"reached recursion limit: {str(e)}\n{error_traceback}",
-            extra={"thread_id": thread_id, "agent_id": input.agent_id},
+            extra={"thread_id": thread_id, "agent_id": user_message.agent_id},
         )
-        error_message_create = ChatMessageCreate(
-            id=str(XID()),
-            agent_id=input.agent_id,
-            chat_id=input.chat_id,
-            user_id=input.user_id,
-            author_id=input.agent_id,
-            author_type=AuthorType.SYSTEM,
-            thread_type=input.author_type,
-            reply_to=input.id,
-            message="Step Limit Error",
+        error_message_create = await ChatMessageCreate.from_system_message(
+            SystemMessageType.STEP_LIMIT_EXCEEDED,
+            agent_id=user_message.agent_id,
+            chat_id=user_message.chat_id,
+            user_id=user_message.user_id,
+            author_id=user_message.agent_id,
+            thread_type=user_message.author_type,
+            reply_to=user_message.id,
             time_cost=time.perf_counter() - start,
         )
         error_message = await error_message_create.save()
@@ -789,22 +821,21 @@ async def stream_agent(message: ChatMessageCreate):
         error_traceback = traceback.format_exc()
         logger.error(
             f"failed to execute agent: {str(e)}\n{error_traceback}",
-            extra={"thread_id": thread_id, "agent_id": input.agent_id},
+            extra={"thread_id": thread_id, "agent_id": user_message.agent_id},
         )
-        error_message_create = ChatMessageCreate(
-            id=str(XID()),
-            agent_id=input.agent_id,
-            chat_id=input.chat_id,
-            user_id=input.user_id,
-            author_id=input.agent_id,
-            author_type=AuthorType.SYSTEM,
-            thread_type=input.author_type,
-            reply_to=input.id,
-            message="Agent Internal Error",
+        error_message_create = await ChatMessageCreate.from_system_message(
+            SystemMessageType.AGENT_INTERNAL_ERROR,
+            agent_id=user_message.agent_id,
+            chat_id=user_message.chat_id,
+            user_id=user_message.user_id,
+            author_id=user_message.agent_id,
+            thread_type=user_message.author_type,
+            reply_to=user_message.id,
             time_cost=time.perf_counter() - start,
         )
         error_message = await error_message_create.save()
         yield error_message
+        await clear_thread_memory(user_message.agent_id, user_message.chat_id)
         return
 
 
@@ -859,14 +890,15 @@ async def clean_agent_memory(
     # get the agent from the database
     try:
         if not clean_skill and not clean_agent:
-            raise HTTPException(
+            raise IntentKitAPIError(
                 status_code=400,
-                detail="at least one of skills data or agent memory should be true.",
+                key="InvalidCleanupParameters",
+                message="at least one of skills data or agent memory should be true",
             )
 
         if clean_skill:
             await AgentSkillData.clean_data(agent_id)
-            await ThreadSkillData.clean_data(agent_id, chat_id)
+            await ChatSkillData.clean_data(agent_id, chat_id)
 
         async with get_session() as db:
             if clean_agent:
@@ -908,7 +940,7 @@ async def clean_agent_memory(
     except SQLAlchemyError as e:
         # Handle other SQLAlchemy-related errors
         logger.error(e)
-        raise HTTPException(status_code=500, detail=str(e))
+        raise IntentKitAPIError(status_code=500, key="DatabaseError", message=str(e))
     except Exception as e:
         logger.error("failed to cleanup the agent memory: " + str(e))
         raise e
@@ -917,10 +949,7 @@ async def clean_agent_memory(
 async def thread_stats(agent_id: str, chat_id: str) -> list[BaseMessage]:
     thread_id = f"{agent_id}-{chat_id}"
     stream_config = {"configurable": {"thread_id": thread_id}}
-    is_private = False
-    if chat_id.startswith("owner") or chat_id.startswith("autonomous"):
-        is_private = True
-    executor, _ = await agent_executor(agent_id, is_private)
+    executor, _ = await agent_executor(agent_id)
     snap = await executor.aget_state(stream_config)
     if snap.values and "messages" in snap.values:
         return snap.values["messages"]