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

intentkit/core/middleware.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Sequence
+from typing import Any
+
+from langchain.agents.middleware import AgentMiddleware
+from langchain.agents.middleware.summarization import SummarizationMiddleware
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    RemoveMessage,
+    ToolMessage,
+)
+from langchain_core.messages.utils import count_tokens_approximately, trim_messages
+from langchain_core.tools import BaseTool
+from langgraph.graph.message import REMOVE_ALL_MESSAGES
+from langgraph.runtime import Runtime
+from langgraph.types import StreamWriter
+
+from intentkit.abstracts.graph import AgentContext, AgentError, AgentState
+from intentkit.core.credit import skill_cost
+from intentkit.core.prompt import build_system_prompt
+from intentkit.models.credit import CreditAccount, OwnerType
+from intentkit.models.llm import LLMModelInfo, LLMProvider
+from intentkit.models.skill import Skill
+
+logger = logging.getLogger(__name__)
+
+
+def _validate_chat_history(messages: Sequence[BaseMessage]) -> None:
+    """Validate that all tool calls in AIMessages have a corresponding ToolMessage."""
+
+    all_tool_calls = [
+        tool_call
+        for message in messages
+        if isinstance(message, AIMessage)
+        for tool_call in message.tool_calls
+    ]
+    tool_call_ids_with_results = {
+        message.tool_call_id for message in messages if isinstance(message, ToolMessage)
+    }
+    tool_calls_without_results = [
+        tool_call
+        for tool_call in all_tool_calls
+        if tool_call["id"] not in tool_call_ids_with_results
+    ]
+    if not tool_calls_without_results:
+        return
+
+    message = (
+        "Found AIMessages with tool_calls that do not have a corresponding ToolMessage. "
+        f"Here are the first few of those tool calls: {tool_calls_without_results[:3]}"
+    )
+    raise ValueError(message)
+
+
+class TrimMessagesMiddleware(AgentMiddleware[AgentState, AgentContext]):
+    """Middleware that trims conversation history before invoking the model."""
+
+    def __init__(self, *, max_summary_tokens: int) -> None:
+        super().__init__()
+        self.max_summary_tokens = max_summary_tokens
+
+    async def abefore_model(
+        self, state: AgentState, runtime: Runtime[AgentContext]
+    ) -> dict[str, Any]:
+        del runtime
+        messages = state.get("messages")
+        context = state.get("context", {})
+        if messages is None or not isinstance(messages, list) or len(messages) == 0:
+            raise ValueError("Missing required field `messages` in the input.")
+        try:
+            _validate_chat_history(messages)
+        except ValueError as e:
+            logger.error(f"Invalid chat history: {e}")
+            logger.info(state)
+            return {"messages": [RemoveMessage(REMOVE_ALL_MESSAGES)]}
+
+        trimmed_messages = trim_messages(
+            messages,
+            strategy="last",
+            token_counter=count_tokens_approximately,
+            max_tokens=self.max_summary_tokens,
+            start_on="human",
+            end_on=("human", "tool"),
+        )
+        if len(trimmed_messages) < len(messages):
+            logger.info(f"Trimmed messages: {len(messages)} -> {len(trimmed_messages)}")
+            if len(trimmed_messages) <= 3:
+                logger.info(f"Too few messages after trim: {len(trimmed_messages)}")
+                return {}
+            return {
+                "messages": [RemoveMessage(REMOVE_ALL_MESSAGES)] + trimmed_messages,
+                "context": context,
+            }
+        return {}
+
+
+class DynamicPromptMiddleware(AgentMiddleware[AgentState, AgentContext]):
+    """Middleware that builds the system prompt dynamically per request."""
+
+    def __init__(self, agent, agent_data) -> None:
+        super().__init__()
+        self.agent = agent
+        self.agent_data = agent_data
+
+    async def awrap_model_call(self, request, handler):  # type: ignore[override]
+        context = request.runtime.context
+        system_prompt = await build_system_prompt(self.agent, self.agent_data, context)
+        updated_request = request.override(system_prompt=system_prompt)
+        return await handler(updated_request)
+
+
+class ToolBindingMiddleware(AgentMiddleware[AgentState, AgentContext]):
+    """Middleware that selects tools and model parameters based on context."""
+
+    def __init__(
+        self,
+        llm_model: LLMModelInfo,
+        public_tools: list[BaseTool | dict],
+        private_tools: list[BaseTool | dict],
+    ) -> None:
+        super().__init__()
+        self.llm_model = llm_model
+        self.public_tools = public_tools
+        self.private_tools = private_tools
+
+    async def awrap_model_call(self, request, handler):  # type: ignore[override]
+        context = request.runtime.context
+
+        llm_params: dict[str, Any] = {}
+        tools: list[BaseTool | dict] = (
+            self.private_tools if context.is_private else self.public_tools
+        )
+        tools = list(
+            {
+                tool.name if isinstance(tool, BaseTool) else str(tool): tool
+                for tool in tools
+            }.values()
+        )
+
+        if context.search or context.agent.has_search():
+            if self.llm_model.info.supports_search:
+                tools.append({"type": "web_search"})
+                if (
+                    self.llm_model.info.provider == LLMProvider.OPENAI
+                    and self.llm_model.model_name == "gpt-5-mini"
+                ):
+                    llm_params["reasoning_effort"] = "medium"
+                if self.llm_model.info.provider == LLMProvider.XAI:
+                    llm_params["search_parameters"] = {"mode": "auto"}
+            else:
+                logger.debug(
+                    "Search requested but model does not support native search"
+                )
+
+        model = await self.llm_model.create_instance(llm_params)
+        updated_request = request.override(
+            model=model,
+            tools=tools,
+            model_settings=llm_params,
+        )
+        return await handler(updated_request)
+
+
+class CreditCheckMiddleware(AgentMiddleware[AgentState, AgentContext]):
+    """Middleware that validates tool affordability before execution."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.func_accepts_config = True
+
+    async def aafter_model(
+        self,
+        state: AgentState,
+        runtime: Runtime[AgentContext],
+        *,
+        writer: StreamWriter | None = None,
+    ) -> dict[str, Any]:
+        context = runtime.context
+        messages = state.get("messages")
+        if messages is None or not isinstance(messages, list) or len(messages) == 0:
+            raise ValueError("Missing required field `messages` in the input.")
+
+        payer = context.payer
+        if not payer:
+            return {}
+
+        msg = messages[-1]
+        agent = context.agent
+        account = await CreditAccount.get_or_create(OwnerType.USER, payer)
+        if hasattr(msg, "tool_calls") and msg.tool_calls:
+            for tool_call in msg.tool_calls:
+                skill_meta = await Skill.get(tool_call.get("name"))
+                if not skill_meta:
+                    continue
+                skill_cost_info = await skill_cost(skill_meta.name, payer, agent)
+                total_paid = skill_cost_info.total_amount
+                if not account.has_sufficient_credits(total_paid):
+                    error_message = (
+                        "Insufficient credits. Please top up your account. "
+                        f"You need {total_paid} credits, but you only have {account.balance} credits."
+                    )
+                    state_update: dict[str, Any] = {
+                        "error": AgentError.INSUFFICIENT_CREDITS,
+                        "messages": [
+                            RemoveMessage(id=msg.id),
+                            AIMessage(content=error_message),
+                        ],
+                    }
+                    if writer:
+                        writer(
+                            {
+                                "credit_check": {
+                                    "error": AgentError.INSUFFICIENT_CREDITS,
+                                    "message": error_message,
+                                }
+                            }
+                        )
+                    return state_update
+        return {}
+
+
+__all__ = [
+    "CreditCheckMiddleware",
+    "DynamicPromptMiddleware",
+    "SummarizationMiddleware",
+    "ToolBindingMiddleware",
+    "TrimMessagesMiddleware",
+]

intentkit/core/prompt.py

@@ -1,17 +1,14 @@
 import re
-from typing import Callable, Optional
 
 from eth_utils import is_address
-from langchain_core.messages import BaseMessage
-from langchain_core.prompts import ChatPromptTemplate
-from langgraph.runtime import Runtime
 
-from intentkit.abstracts.graph import AgentContext, AgentState
+from intentkit.abstracts.graph import AgentContext
 from intentkit.config.config import config
 from intentkit.models.agent import Agent
 from intentkit.models.agent_data import AgentData
 from intentkit.models.chat import AuthorType
 from intentkit.models.skill import Skill
+from intentkit.models.user import User
 
 # ============================================================================
 # CONSTANTS AND CONFIGURATION
@@ -34,7 +31,6 @@ user confirmation before broadcasting any approval transactions for security rea
 
 """
 
-
 # ============================================================================
 # CORE PROMPT BUILDING FUNCTIONS
 # ============================================================================
@@ -110,28 +106,66 @@ def _build_wallet_section(agent: Agent, agent_data: AgentData) -> str:
 
     if agent_data.evm_wallet_address and network_id != "solana":
         wallet_parts.append(
-            f"Your wallet address in {network_id} is {agent_data.evm_wallet_address}."
+            f"Your EVM wallet address is {agent_data.evm_wallet_address}."
+            f"You are now in {network_id} network."
         )
     if agent_data.solana_wallet_address and network_id == "solana":
         wallet_parts.append(
-            f"Your wallet address in {network_id} is {agent_data.solana_wallet_address}."
+            f"Your Solana wallet address is {agent_data.solana_wallet_address}."
+            f"You are now in {network_id} network."
         )
 
+    # Add CDP skills prompt if CDP skills are enabled
+    if agent.skills and "cdp" in agent.skills:
+        cdp_config = agent.skills["cdp"]
+        if cdp_config and cdp_config.get("enabled") is True:
+            # Check if any CDP skills are in public or private state (not disabled)
+            states = cdp_config.get("states", {})
+            has_enabled_cdp_skills = any(
+                state in ["public", "private"] for state in states.values()
+            )
+            if has_enabled_cdp_skills:
+                wallet_parts.append(
+                    "If a skill input parameter requires a token address but you only have the user-provided token symbol, "
+                    "and the address cannot be found in the nearby context, you must use the `token_search` skill to query "
+                    f"the address of that symbol on the current chain ({network_id}) and confirm this address with the user."
+                    "If the `token_search` skill is not found, remind the user to enable it."
+                )
+
     return "\n".join(wallet_parts) + ("\n" if wallet_parts else "")
 
 
-def _build_user_info_section(context: AgentContext) -> str:
+async def _build_user_info_section(context: AgentContext) -> str:
     """Build user information section when user_id is a valid EVM wallet address."""
     if not context.user_id:
         return ""
 
-    # Check if user_id is a valid EVM wallet address
-    try:
-        if is_address(context.user_id):
-            return f"## User Info\n\nThe person you are talking to has wallet address: {context.user_id}\n\n"
-    except Exception:
-        # If validation fails, don't include the section
-        pass
+    user = await User.get(context.user_id)
+
+    prompt_array = []
+
+    evm_wallet_address = ""
+    if user and user.evm_wallet_address:
+        evm_wallet_address = user.evm_wallet_address
+    elif is_address(context.user_id):
+        evm_wallet_address = context.user_id
+
+    if evm_wallet_address:
+        prompt_array.append(
+            f"The user you are talking to has EVM wallet address: {evm_wallet_address}\n"
+        )
+
+    if user:
+        if user.email:
+            prompt_array.append(f"User Email: {user.email}\n")
+        if user.x_username:
+            prompt_array.append(f"User X Username: {user.x_username}\n")
+        if user.telegram_username:
+            prompt_array.append(f"User Telegram Username: {user.telegram_username}\n")
+
+    if prompt_array:
+        prompt_array.append("\n")
+        return "## User Info\n\n" + "".join(prompt_array)
 
     return ""
 
@@ -202,36 +236,19 @@ def agent_prompt(agent: Agent, agent_data: AgentData) -> str:
 
 
 async def explain_prompt(message: str) -> str:
-    """
-    Process message to replace @skill:*:* patterns with (call skill xxxxx) format.
-    This function is used when admin_llm_skill_control is enabled.
-
-    Args:
-        message (str): The input message to process
-
-    Returns:
-        str: The processed message with @skill patterns replaced
-    """
-    # Pattern to match @skill:category:config_name with word boundaries
-    pattern = r"\b@skill:([^:]+):([^\s]+)\b"
+    pattern = r"@skill:([^:]+):([^\s]+)\b"
 
     async def replace_skill_pattern(match):
         category = match.group(1)
         config_name = match.group(2)
 
-        # Get skill by category and config_name
         skill = await Skill.get_by_config_name(category, config_name)
-
         if skill:
             return f"(call skill {skill.name})"
         else:
-            # If skill not found, keep original pattern
             return match.group(0)
 
-    # Find all matches
     matches = list(re.finditer(pattern, message))
-
-    # Process matches in reverse order to maintain string positions
     result = message
     for match in reversed(matches):
         replacement = await replace_skill_pattern(match)
@@ -290,7 +307,7 @@ def _build_autonomous_task_prompt(agent: Agent, context: AgentContext) -> str:
     return f"{task_info}. "
 
 
-async def build_entrypoint_prompt(agent: Agent, context: AgentContext) -> Optional[str]:
+async def build_entrypoint_prompt(agent: Agent, context: AgentContext) -> str | None:
     """
     Build entrypoint-specific prompt based on context.
 
@@ -303,7 +320,7 @@ async def build_entrypoint_prompt(agent: Agent, context: AgentContext) -> Option
         context: The agent context containing entrypoint information
 
     Returns:
-        Optional[str]: The entrypoint-specific prompt, or None if no entrypoint
+        str | None: The entrypoint-specific prompt, or None if no entrypoint
     """
     if not context.entrypoint:
         return None
@@ -325,10 +342,6 @@ async def build_entrypoint_prompt(agent: Agent, context: AgentContext) -> Option
     elif entrypoint == AuthorType.TRIGGER.value:
         entrypoint_prompt = "\n\n" + _build_autonomous_task_prompt(agent, context)
 
-    # Process with admin LLM skill control if enabled
-    if entrypoint_prompt and config.admin_llm_skill_control:
-        entrypoint_prompt = await explain_prompt(entrypoint_prompt)
-
     return entrypoint_prompt
 
 
@@ -348,83 +361,30 @@ def build_internal_info_prompt(context: AgentContext) -> str:
 # ============================================================================
 
 
-def create_formatted_prompt_function(agent: Agent, agent_data: AgentData) -> Callable:
-    """
-    Create the formatted_prompt function with agent-specific configuration.
+async def build_system_prompt(
+    agent: Agent, agent_data: AgentData, context: AgentContext
+) -> str:
+    """Construct the final system prompt for an agent run."""
 
-    This is the main factory function that creates a prompt formatting function
-    tailored to a specific agent. The returned function will be used by the
-    agent's runtime to format prompts for each conversation.
+    base_prompt = build_agent_prompt(agent, agent_data)
+    final_system_prompt = await explain_prompt(escape_prompt(base_prompt))
 
-    Args:
-        agent: The agent configuration
-        agent_data: The agent's runtime data
-
-    Returns:
-        Callable: An async function that formats prompts based on agent state and context
-    """
-    # Build base prompt using the new function name
-    prompt = build_agent_prompt(agent, agent_data)
-    escaped_prompt = escape_prompt(prompt)
-
-    # Process with admin LLM skill control if enabled
-    async def get_base_prompt():
-        if config.admin_llm_skill_control:
-            return await explain_prompt(escaped_prompt)
-        return escaped_prompt
-
-    # Build prompt array
-    prompt_array = [
-        ("placeholder", "{system_prompt}"),
-        ("placeholder", "{messages}"),
-    ]
-
-    if agent.prompt_append:
-        # Escape any curly braces in prompt_append
-        escaped_append = escape_prompt(agent.prompt_append)
-        prompt_array.append(("system", escaped_append))
-
-    prompt_temp = ChatPromptTemplate.from_messages(prompt_array)
-
-    async def formatted_prompt(
-        state: AgentState, runtime: Runtime[AgentContext]
-    ) -> list[BaseMessage]:
-        # Get base prompt (with potential admin LLM skill control processing)
-        final_system_prompt = await get_base_prompt()
+    entrypoint_prompt = await build_entrypoint_prompt(agent, context)
+    if entrypoint_prompt:
+        processed_entrypoint = await explain_prompt(entrypoint_prompt)
+        final_system_prompt = (
+            f"{final_system_prompt}## Entrypoint rules{processed_entrypoint}\n\n"
+        )
 
-        context = runtime.context
+    user_info = await _build_user_info_section(context)
+    if user_info:
+        final_system_prompt = f"{final_system_prompt}{user_info}"
 
-        # Add entrypoint prompt if applicable
-        entrypoint_prompt = await build_entrypoint_prompt(agent, context)
-        if entrypoint_prompt:
-            final_system_prompt = (
-                f"{final_system_prompt}## Entrypoint rules{entrypoint_prompt}\n\n"
-            )
+    internal_info = build_internal_info_prompt(context)
+    final_system_prompt = f"{final_system_prompt}{internal_info}"
 
-        # Add user info if user_id is a valid EVM wallet address
-        user_info = _build_user_info_section(context)
-        if user_info:
-            final_system_prompt = f"{final_system_prompt}{user_info}"
-
-        # Add internal info
-        internal_info = build_internal_info_prompt(context)
-        final_system_prompt = f"{final_system_prompt}{internal_info}"
-
-        # Process prompt_append with admin LLM skill control if needed
-        if agent.prompt_append and config.admin_llm_skill_control:
-            # Find the system message in prompt_array and process it
-            for i, (role, content) in enumerate(prompt_array):
-                if role == "system":
-                    processed_append = await explain_prompt(content)
-                    prompt_array[i] = ("system", processed_append)
-                    break
-
-        system_prompt = [("system", final_system_prompt)]
-        return prompt_temp.invoke(
-            {
-                "messages": state["messages"],
-                "system_prompt": system_prompt,
-            }
-        )
+    if agent.prompt_append:
+        processed_append = await explain_prompt(agent.prompt_append)
+        final_system_prompt = f"{final_system_prompt}{processed_append}"
 
-    return formatted_prompt
+    return final_system_prompt

intentkit/core/scheduler.py

@@ -0,0 +1,143 @@
+"""Core scheduler utilities."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, MutableMapping
+
+from apscheduler.jobstores.base import BaseJobStore
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.cron import CronTrigger
+
+from intentkit.core.agent import (
+    update_agent_action_cost,
+    update_agents_account_snapshot,
+    update_agents_statistics,
+)
+from intentkit.core.credit import refill_all_free_credits
+from intentkit.models.agent_data import AgentQuota
+
+
+def create_scheduler(
+    jobstores: Mapping[str, BaseJobStore]
+    | MutableMapping[str, BaseJobStore]
+    | None = None,
+) -> AsyncIOScheduler:
+    """Create and configure the APScheduler with all periodic tasks."""
+    scheduler = AsyncIOScheduler(jobstores=dict(jobstores or {}))
+
+    # Reset daily quotas at UTC 00:00
+    scheduler.add_job(
+        AgentQuota.reset_daily_quotas,
+        trigger=CronTrigger(hour=0, minute=0, timezone="UTC"),
+        id="reset_daily_quotas",
+        name="Reset daily quotas",
+        replace_existing=True,
+    )
+
+    # Reset monthly quotas at UTC 00:00 on the first day of each month
+    scheduler.add_job(
+        AgentQuota.reset_monthly_quotas,
+        trigger=CronTrigger(day=1, hour=0, minute=0, timezone="UTC"),
+        id="reset_monthly_quotas",
+        name="Reset monthly quotas",
+        replace_existing=True,
+    )
+
+    # Refill free credits every hour at minute 20
+    scheduler.add_job(
+        refill_all_free_credits,
+        trigger=CronTrigger(minute="20", timezone="UTC"),
+        id="refill_free_credits",
+        name="Refill free credits",
+        replace_existing=True,
+    )
+
+    # Update agent account snapshots hourly
+    scheduler.add_job(
+        update_agents_account_snapshot,
+        trigger=CronTrigger(minute=0, timezone="UTC"),
+        id="update_agent_account_snapshot",
+        name="Update agent account snapshots",
+        replace_existing=True,
+    )
+
+    # Update agent assets daily at UTC midnight
+    # This is too expensive to run daily, so it will only be triggered when detail page is visited
+    # scheduler.add_job(
+    #     update_agents_assets,
+    #     trigger=CronTrigger(hour=0, minute=0, timezone="UTC"),
+    #     id="update_agent_assets",
+    #     name="Update agent assets",
+    #     replace_existing=True,
+    # )
+
+    # Update agent action costs hourly at minute 40
+    scheduler.add_job(
+        update_agent_action_cost,
+        trigger=CronTrigger(minute="40", timezone="UTC"),
+        id="update_agent_action_cost",
+        name="Update agent action costs",
+        replace_existing=True,
+    )
+
+    # Update agent statistics daily at UTC 00:01
+    scheduler.add_job(
+        update_agents_statistics,
+        trigger=CronTrigger(hour=0, minute=1, timezone="UTC"),
+        id="update_agent_statistics",
+        name="Update agent statistics",
+        replace_existing=True,
+    )
+
+    # Run quick account consistency checks every 2 hours at the top of the hour
+    # Run quick account consistency checks every 2 hours at the top of the hour
+    from intentkit.core.account_checking import run_quick_checks, run_slow_checks
+
+    async def run_quick_account_checks():
+        """Run quick account consistency checks and send results to Slack."""
+        # logger is not defined in this scope, so we use a local logger or print
+        # But better to use the one from the module if we move the logger definition up or import it
+        import logging
+
+        logger = logging.getLogger(__name__)
+        logger.info("Running scheduled quick account consistency checks")
+        try:
+            _ = await run_quick_checks()
+            logger.info("Completed quick account consistency checks")
+        except Exception as e:
+            logger.error(f"Error running quick account consistency checks: {e}")
+
+    async def run_slow_account_checks():
+        """Run slow account consistency checks and send results to Slack."""
+        import logging
+
+        logger = logging.getLogger(__name__)
+        logger.info("Running scheduled slow account consistency checks")
+        try:
+            _ = await run_slow_checks()
+            logger.info("Completed slow account consistency checks")
+        except Exception as e:
+            logger.error(f"Error running slow account consistency checks: {e}")
+
+    scheduler.add_job(
+        run_quick_account_checks,
+        trigger=CronTrigger(
+            hour="*/2", minute="30", timezone="UTC"
+        ),  # Run every 2 hours
+        id="quick_account_checks",
+        name="Quick Account Consistency Checks",
+        replace_existing=True,
+    )
+
+    # Run slow account consistency checks once a day at midnight UTC
+    scheduler.add_job(
+        run_slow_account_checks,
+        trigger=CronTrigger(
+            hour="0,12", minute="0", timezone="UTC"
+        ),  # Run 2 times a day
+        id="slow_account_checks",
+        name="Slow Account Consistency Checks",
+        replace_existing=True,
+    )
+
+    return scheduler