intentkit 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

intentkit/core/node.py

@@ -0,0 +1,223 @@
+import logging
+from typing import Any, Sequence
+
+from langchain_core.language_models import LanguageModelLike
+from langchain_core.messages import (
+    AIMessage,
+    AnyMessage,
+    BaseMessage,
+    HumanMessage,
+    RemoveMessage,
+    ToolMessage,
+)
+from langchain_core.messages.utils import count_tokens_approximately, trim_messages
+from langchain_core.runnables import RunnableConfig
+from langgraph.graph.message import REMOVE_ALL_MESSAGES
+from langgraph.utils.runnable import RunnableCallable
+from langmem.short_term.summarization import (
+    DEFAULT_EXISTING_SUMMARY_PROMPT,
+    DEFAULT_FINAL_SUMMARY_PROMPT,
+    DEFAULT_INITIAL_SUMMARY_PROMPT,
+    SummarizationResult,
+    asummarize_messages,
+)
+from pydantic import BaseModel
+
+from intentkit.abstracts.graph import AgentError, AgentState
+from intentkit.core.credit import skill_cost
+from intentkit.models.credit import CreditAccount, OwnerType
+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 PreModelNode(RunnableCallable):
+    """LangGraph node that run before the LLM is called."""
+
+    def __init__(
+        self,
+        *,
+        model: LanguageModelLike,
+        short_term_memory_strategy: str,
+        max_tokens: int,
+        max_summary_tokens: int = 1024,
+    ) -> None:
+        super().__init__(self._func, self._afunc, name="pre_model_node", trace=False)
+        self.model = model
+        self.short_term_memory_strategy = short_term_memory_strategy
+        self.max_tokens = max_tokens
+        self.max_tokens_before_summary = max_tokens
+        self.max_summary_tokens = max_summary_tokens
+        self.token_counter = count_tokens_approximately
+        self.initial_summary_prompt = DEFAULT_INITIAL_SUMMARY_PROMPT
+        self.existing_summary_prompt = DEFAULT_EXISTING_SUMMARY_PROMPT
+        self.final_prompt = DEFAULT_FINAL_SUMMARY_PROMPT
+        self.func_accepts_config = True
+
+    def _parse_input(
+        self, input: AgentState
+    ) -> tuple[list[AnyMessage], dict[str, Any]]:
+        messages = input.get("messages")
+        context = input.get("context", {})
+        if messages is None or not isinstance(messages, list) or len(messages) == 0:
+            raise ValueError("Missing required field `messages` in the input.")
+        return messages, context
+
+    # overwrite old messages if summarization is used
+    def _prepare_state_update(
+        self, context: dict[str, Any], summarization_result: SummarizationResult
+    ) -> dict[str, Any]:
+        state_update = {
+            "messages": [RemoveMessage(REMOVE_ALL_MESSAGES)]
+            + summarization_result.messages
+        }
+        if summarization_result.running_summary:
+            state_update["context"] = {
+                **context,
+                "running_summary": summarization_result.running_summary,
+            }
+        return state_update
+
+    def _func(self, AgentState) -> dict[str, Any]:
+        raise NotImplementedError("Not implemented yet")
+
+    async def _afunc(
+        self,
+        input: AgentState,
+        config: RunnableConfig,
+    ) -> dict[str, Any]:
+        messages, context = self._parse_input(input)
+        try:
+            _validate_chat_history(messages)
+        except ValueError as e:
+            logger.error(f"Invalid chat history: {e}")
+            logger.info(input)
+            # delete all messages
+            return {"messages": [RemoveMessage(REMOVE_ALL_MESSAGES)]}
+        if self.short_term_memory_strategy == "trim":
+            trimmed_messages = trim_messages(
+                messages,
+                strategy="last",
+                token_counter=self.token_counter,
+                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.error(
+                        f"Too few messages after trim: {len(trimmed_messages)}"
+                    )
+                    return {}
+            return {
+                "messages": [RemoveMessage(REMOVE_ALL_MESSAGES)] + trimmed_messages,
+            }
+        if self.short_term_memory_strategy == "summarize":
+            # if last message is not human message, skip summarize
+            if not isinstance(messages[-1], HumanMessage):
+                return {}
+            # summarization is from outside, sometimes it is not stable, so we need to try-catch it
+            try:
+                summarization_result = await asummarize_messages(
+                    messages,
+                    running_summary=context.get("running_summary"),
+                    model=self.model,
+                    max_tokens=self.max_tokens,
+                    max_tokens_before_summary=self.max_tokens_before_summary,
+                    max_summary_tokens=self.max_summary_tokens,
+                    token_counter=self.token_counter,
+                    initial_summary_prompt=self.initial_summary_prompt,
+                    existing_summary_prompt=self.existing_summary_prompt,
+                    final_prompt=self.final_prompt,
+                )
+                if summarization_result.running_summary:
+                    logger.debug(f"Summarization result: {summarization_result}")
+                else:
+                    logger.debug("Summarization not run")
+                return self._prepare_state_update(context, summarization_result)
+            except ValueError as e:
+                logger.error(f"Invalid chat history: {e}")
+                logger.info(input)
+                # delete all messages
+                return {"messages": [RemoveMessage(REMOVE_ALL_MESSAGES)]}
+        raise ValueError(
+            f"Invalid short_term_memory_strategy: {self.short_term_memory_strategy}"
+        )
+
+
+class PostModelNode(RunnableCallable):
+    def __init__(self) -> None:
+        super().__init__(self._func, self._afunc, name="post_model_node", trace=False)
+        self.func_accepts_config = True
+
+    def _func(self, input: dict[str, Any] | BaseModel) -> dict[str, Any]:
+        raise NotImplementedError("Not implemented yet")
+
+    async def _afunc(
+        self,
+        input: AgentState,
+        config: RunnableConfig,
+    ) -> dict[str, Any]:
+        logger.debug(f"Running PostModelNode, input: {input}, config: {config}")
+        state_update = {}
+        messages = input.get("messages")
+        if messages is None or not isinstance(messages, list) or len(messages) == 0:
+            raise ValueError("Missing required field `messages` in the input.")
+        cfg = config.get("configurable")
+        if not config:
+            raise ValueError("Missing required field `configurable` in the config.")
+        payer = cfg.get("payer")
+        if not payer:
+            return state_update
+        logger.debug(f"last: {messages[-1]}")
+        msg = messages[-1]
+        agent = cfg.get("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 skill_meta:
+                    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):
+                        state_update["error"] = AgentError.INSUFFICIENT_CREDITS
+                        state_update["messages"] = [RemoveMessage(id=msg.id)]
+                        state_update["messages"].append(
+                            AIMessage(
+                                content=f"Insufficient credits. Please top up your account. You need {total_paid} credits, but you only have {account.balance} credits.",
+                            )
+                        )
+                        return state_update
+        return state_update
+
+
+post_model_node = PostModelNode()

intentkit/core/prompt.py

@@ -0,0 +1,58 @@
+import json
+
+from intentkit.config.config import config
+from intentkit.models.agent import Agent
+from intentkit.models.agent_data import AgentData
+
+
+def agent_prompt(agent: Agent, agent_data: AgentData) -> str:
+    prompt = "# SYSTEM PROMPT\n\n"
+    if config.system_prompt:
+        prompt += config.system_prompt + "\n\n"
+    prompt += "You are an AI agent built using IntentKit.\n"
+    prompt += "Your tools are called 'skills'.\n"
+    prompt += "If your skill fails to execute due to a technical error ask the user to try again later, don't retry by yourself. If someone asks you to do something you can't do with your currently available skills, you must say so, recommend them to submit their feedback to the IntentKit team at https://github.com/crestalnetwork/intentkit. Be concise and helpful with your responses.\n"
+    if agent.name:
+        prompt += f"Your name is {agent.name}.\n"
+    if agent.ticker:
+        prompt += f"Your ticker symbol is {agent.ticker}.\n"
+    if agent_data:
+        if agent_data.twitter_id:
+            prompt += f"Your twitter id is {agent_data.twitter_id}, never reply or retweet yourself.\n"
+        if agent_data.twitter_username:
+            prompt += f"Your twitter username is {agent_data.twitter_username}.\n"
+        if agent_data.twitter_name:
+            prompt += f"Your twitter name is {agent_data.twitter_name}.\n"
+        if agent_data.twitter_is_verified:
+            prompt += "Your twitter account is verified.\n"
+        else:
+            prompt += "Your twitter account is not verified.\n"
+        if agent_data.telegram_id:
+            prompt += f"Your telegram bot id is {agent_data.telegram_id}.\n"
+        if agent_data.telegram_username:
+            prompt += f"Your telegram bot username is {agent_data.telegram_username}.\n"
+        if agent_data.telegram_name:
+            prompt += f"Your telegram bot name is {agent_data.telegram_name}.\n"
+        # CDP
+        if agent_data.cdp_wallet_data:
+            network_id = agent.network_id or agent.cdp_network_id
+            wallet_data = json.loads(agent_data.cdp_wallet_data)
+            prompt += f"Your wallet address in {network_id} is {wallet_data['default_address_id']} .\n"
+    prompt += "\n"
+    if agent.purpose:
+        prompt += f"## Purpose\n\n{agent.purpose}\n\n"
+    if agent.personality:
+        prompt += f"## Personality\n\n{agent.personality}\n\n"
+    if agent.principles:
+        prompt += f"## Principles\n\n{agent.principles}\n\n"
+    if agent.prompt:
+        prompt += f"## Initial Rules\n\n{agent.prompt}\n\n"
+    if agent.skills and "enso" in agent.skills and agent.skills["enso"].get("enabled"):
+        prompt += """## ENSO Skills Guide\n\nYou are integrated with the Enso API. You can use enso_get_tokens to retrieve token information,
+        including APY, Protocol Slug, Symbol, Address, Decimals, and underlying tokens. When interacting with token amounts,
+        ensure to multiply input amounts by the token's decimal places and divide output amounts by the token's decimals. 
+        Utilize enso_route_shortcut to find the best swap or deposit route. Set broadcast_request to True only when the 
+        user explicitly requests a transaction broadcast. Insufficient funds or insufficient spending approval can cause 
+        Route Shortcut broadcasts to fail. To avoid this, use the enso_broadcast_wallet_approve tool that requires explicit 
+        user confirmation before broadcasting any approval transactions for security reasons.\n\n"""
+    return prompt

intentkit/core/skill.py

@@ -0,0 +1,124 @@
+from typing import Any, Dict, Optional
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.config.config import config
+from intentkit.models.agent import Agent
+from intentkit.models.agent_data import AgentData, AgentQuota
+from intentkit.models.skill import (
+    AgentSkillData,
+    AgentSkillDataCreate,
+    ThreadSkillData,
+    ThreadSkillDataCreate,
+)
+
+
+class SkillStore(SkillStoreABC):
+    """Implementation of skill data storage operations.
+
+    This class provides concrete implementations for storing and retrieving
+    skill-related data for both agents and threads.
+    """
+
+    @staticmethod
+    def get_system_config(key: str) -> Any:
+        # TODO: maybe need a whitelist here
+        if hasattr(config, key):
+            return getattr(config, key)
+        return None
+
+    @staticmethod
+    async def get_agent_config(agent_id: str) -> Optional[Agent]:
+        return await Agent.get(agent_id)
+
+    @staticmethod
+    async def get_agent_data(agent_id: str) -> Optional[AgentData]:
+        return await AgentData.get(agent_id)
+
+    @staticmethod
+    async def set_agent_data(agent_id: str, data: Dict) -> None:
+        return await AgentData.patch(agent_id, data)
+
+    @staticmethod
+    async def get_agent_quota(agent_id: str) -> Optional[AgentQuota]:
+        return await AgentQuota.get(agent_id)
+
+    @staticmethod
+    async def get_agent_skill_data(
+        agent_id: str, skill: str, key: str
+    ) -> Optional[Dict[str, Any]]:
+        """Get skill data for an agent.
+
+        Args:
+            agent_id: ID of the agent
+            skill: Name of the skill
+            key: Data key
+
+        Returns:
+            Dictionary containing the skill data if found, None otherwise
+        """
+        return await AgentSkillData.get(agent_id, skill, key)
+
+    @staticmethod
+    async def save_agent_skill_data(
+        agent_id: str, skill: str, key: str, data: Dict[str, Any]
+    ) -> None:
+        """Save or update skill data for an agent.
+
+        Args:
+            agent_id: ID of the agent
+            skill: Name of the skill
+            key: Data key
+            data: JSON data to store
+        """
+        skill_data = AgentSkillDataCreate(
+            agent_id=agent_id,
+            skill=skill,
+            key=key,
+            data=data,
+        )
+        await skill_data.save()
+
+    @staticmethod
+    async def get_thread_skill_data(
+        thread_id: str, skill: str, key: str
+    ) -> Optional[Dict[str, Any]]:
+        """Get skill data for a thread.
+
+        Args:
+            thread_id: ID of the thread
+            skill: Name of the skill
+            key: Data key
+
+        Returns:
+            Dictionary containing the skill data if found, None otherwise
+        """
+        return await ThreadSkillData.get(thread_id, skill, key)
+
+    @staticmethod
+    async def save_thread_skill_data(
+        thread_id: str,
+        agent_id: str,
+        skill: str,
+        key: str,
+        data: Dict[str, Any],
+    ) -> None:
+        """Save or update skill data for a thread.
+
+        Args:
+            thread_id: ID of the thread
+            agent_id: ID of the agent that owns this thread
+            skill: Name of the skill
+            key: Data key
+            data: JSON data to store
+        """
+        skill_data = ThreadSkillDataCreate(
+            thread_id=thread_id,
+            agent_id=agent_id,
+            skill=skill,
+            key=key,
+            data=data,
+        )
+        await skill_data.save()
+
+
+skill_store = SkillStore()