intentkit 0.8.17.dev2__tar.gz → 0.8.27.dev1__tar.gz

intentkit-0.8.27.dev1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Crestal Network
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{intentkit-0.8.17.dev2 → intentkit-0.8.27.dev1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.8.17.dev2
+Version: 0.8.27.dev1
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestalnetwork/intentkit
 Project-URL: Repository, https://github.com/crestalnetwork/intentkit
 Project-URL: Documentation, https://github.com/crestalnetwork/intentkit/tree/main/docs
 Project-URL: Bug Tracker, https://github.com/crestalnetwork/intentkit/issues
-Author-email: hyacinthus <hyacinthus@gmail.com>
+Author-email: Ruihua <ruihua@crestal.network>
 License: MIT License
         
         Copyright (c) 2024 Crestal Network
@@ -69,14 +69,14 @@ Requires-Dist: langgraph>=0.6.1
 Requires-Dist: langmem>=0.0.27
 Requires-Dist: mypy-boto3-s3<2.0.0,>=1.37.24
 Requires-Dist: openai>=1.59.6
-Requires-Dist: pillow<12.0.0,>=11.1.0
+Requires-Dist: pillow<13.0.0,>=11.1.0
 Requires-Dist: psycopg-pool>=3.2.4
 Requires-Dist: psycopg>=3.2.9
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: pytz>=2025.1
 Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: redis<7.0.0,>=5.2.1
+Requires-Dist: redis<8.0.0,>=5.2.1
 Requires-Dist: requests-oauthlib>=2.0.0
 Requires-Dist: requests>=2.32.3
 Requires-Dist: slack-sdk>=3.34.0

{intentkit-0.8.17.dev2 → intentkit-0.8.27.dev1/intentkit}/MANIFEST.in

@@ -1,6 +1,5 @@
 include README.md
 include LICENSE
-include pyproject.toml
 recursive-include abstracts *.py
 recursive-include clients *.py
 recursive-include config *.py
@@ -12,4 +11,4 @@ recursive-exclude * __pycache__
 recursive-exclude * *.pyc
 recursive-exclude * *.pyo
 recursive-exclude * .DS_Store
-recursive-exclude * .ruff_cache
+recursive-exclude * .ruff_cache

{intentkit-0.8.17.dev2 → intentkit-0.8.27.dev1/intentkit}/__init__.py

@@ -3,15 +3,17 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.8.17-dev2"
-__author__ = "hyacinthus"
-__email__ = "hyacinthus@gmail.com"
+__version__ = "0.8.27-dev1"
+__author__ = "Ruihua"
+__email__ = "ruihua@crestal.network"
 
 # Core components
 # Abstract base classes
-from .core.engine import create_agent, stream_agent
+from .core.engine import build_agent, create_agent, stream_agent, stream_agent_raw
 
 __all__ = [
     "create_agent",
     "stream_agent",
+    "build_agent",
+    "stream_agent_raw",
 ]

intentkit-0.8.27.dev1/intentkit/config/config.py

@@ -0,0 +1,240 @@
+import json
+import logging
+import os
+from typing import overload
+
+from dotenv import load_dotenv
+
+from intentkit.utils.chain import ChainProvider, QuicknodeChainProvider
+from intentkit.utils.logging import setup_logging
+from intentkit.utils.s3 import init_s3
+from intentkit.utils.slack_alert import init_slack
+
+SecretsMap = dict[str, str | int]
+DatabaseConfig = dict[str, str | int | bool]
+
+# Load environment variables from .env file
+_ = load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+
+def load_from_aws(name: str) -> SecretsMap:
+    import botocore.session
+    from aws_secretsmanager_caching import SecretCache, SecretCacheConfig
+
+    client = botocore.session.get_session().create_client("secretsmanager")
+    cache_config = SecretCacheConfig()
+    cache = SecretCache(config=cache_config, client=client)
+    secret = cache.get_secret_string(name)
+    return json.loads(secret)
+
+
+class Config:
+    def __init__(self) -> None:
+        # ==== this part can only be load from env
+        self.env: str = os.getenv("ENV", "local")
+        self.release: str = os.getenv("RELEASE", "local")
+        secret_name: str | None = os.getenv("AWS_SECRET_NAME")
+        db_secret_name: str | None = os.getenv("AWS_DB_SECRET_NAME")
+        # ==== load from aws secrets manager
+        self.secrets: SecretsMap = {}
+        if secret_name:
+            self.secrets = load_from_aws(secret_name)
+        self.db: DatabaseConfig
+        if db_secret_name:
+            secret_db: SecretsMap = load_from_aws(db_secret_name)
+            # format the db config
+            secret_db["port"] = str(secret_db["port"])
+            # only keep the necessary fields
+            self.db = {
+                k: v
+                for k, v in secret_db.items()
+                if k in ["username", "password", "host", "dbname", "port"]
+            }
+        else:
+            self.db = {
+                "username": self.load("DB_USERNAME", ""),
+                "password": self.load("DB_PASSWORD", ""),
+                "host": self.load("DB_HOST", ""),
+                "port": self.load("DB_PORT", "5432"),
+                "dbname": self.load("DB_NAME", ""),
+            }
+        # ==== this part can be load from env or aws secrets manager
+        self.db["auto_migrate"] = self.load("DB_AUTO_MIGRATE", "true") == "true"
+        self.db["pool_size"] = self.load_int("DB_POOL_SIZE", 3)
+        self.debug: bool = self.load("DEBUG") == "true"
+        self.debug_checkpoint: bool = (
+            self.load("DEBUG_CHECKPOINT", "false") == "true"
+        )  # log with checkpoint
+        # Redis
+        self.redis_host: str | None = self.load("REDIS_HOST")
+        self.redis_port: int = self.load_int("REDIS_PORT", 6379)
+        self.redis_db: int = self.load_int("REDIS_DB", 0)
+        # AWS
+        self.aws_s3_bucket: str | None = self.load("AWS_S3_BUCKET")
+        self.aws_s3_cdn_url: str | None = self.load("AWS_S3_CDN_URL")
+        # Internal API
+        self.internal_base_url: str = self.load(
+            "INTERNAL_BASE_URL", "http://intent-api"
+        )
+        self.admin_auth_enabled: bool = (
+            self.load("ADMIN_AUTH_ENABLED", "false") == "true"
+        )
+        self.admin_jwt_secret: str | None = self.load("ADMIN_JWT_SECRET")
+        self.debug_auth_enabled: bool = (
+            self.load("DEBUG_AUTH_ENABLED", "false") == "true"
+        )
+        self.debug_username: str | None = self.load("DEBUG_USERNAME")
+        self.debug_password: str | None = self.load("DEBUG_PASSWORD")
+        # Payment
+        self.payment_enabled: bool = self.load("PAYMENT_ENABLED", "false") == "true"
+        self.x402_fee_address: str | None = self.load("X402_FEE_ADDRESS")
+        # Open API for agent
+        self.open_api_base_url: str = self.load(
+            "OPEN_API_BASE_URL", "http://localhost:8000"
+        )
+        # CDP - AgentKit 0.7.x Configuration
+        self.cdp_api_key_id: str | None = self.load("CDP_API_KEY_ID")
+        self.cdp_api_key_secret: str | None = self.load("CDP_API_KEY_SECRET")
+        self.cdp_wallet_secret: str | None = self.load("CDP_WALLET_SECRET")
+        # LLM providers
+        self.openai_api_key: str | None = self.load("OPENAI_API_KEY")
+        self.deepseek_api_key: str | None = self.load("DEEPSEEK_API_KEY")
+        self.xai_api_key: str | None = self.load("XAI_API_KEY")
+        self.eternal_api_key: str | None = self.load("ETERNAL_API_KEY")
+        self.reigent_api_key: str | None = self.load("REIGENT_API_KEY")
+        self.venice_api_key: str | None = self.load("VENICE_API_KEY")
+        self.gatewayz_api_key: str | None = self.load("GATEWAYZ_API_KEY")
+        # LLM Config
+        self.system_prompt: str | None = self.load("SYSTEM_PROMPT")
+        self.intentkit_prompt: str | None = self.load("INTENTKIT_PROMPT")
+        self.input_token_limit: int = self.load_int("INPUT_TOKEN_LIMIT", 60000)
+        # XMTP
+        self.xmtp_system_prompt: str | None = self.load(
+            "XMTP_SYSTEM_PROMPT",
+            "You are assisting a user who uses an XMTP client that only displays plain-text messages, so do not use Markdown formatting.",
+        )
+        # Telegram server settings
+        self.tg_system_prompt: str | None = self.load("TG_SYSTEM_PROMPT")
+        self.tg_base_url: str | None = self.load("TG_BASE_URL")
+        self.tg_server_host: str = self.load("TG_SERVER_HOST", "127.0.0.1")
+        self.tg_server_port: str = self.load("TG_SERVER_PORT", "8081")
+        self.tg_new_agent_poll_interval: str = self.load(
+            "TG_NEW_AGENT_POLL_INTERVAL", "60"
+        )
+        # Discord server settings
+        self.discord_new_agent_poll_interval: str = self.load(
+            "DISCORD_NEW_AGENT_POLL_INTERVAL", "30"
+        )
+        # Twitter
+        self.twitter_oauth2_client_id: str | None = self.load(
+            "TWITTER_OAUTH2_CLIENT_ID"
+        )
+        self.twitter_oauth2_client_secret: str | None = self.load(
+            "TWITTER_OAUTH2_CLIENT_SECRET"
+        )
+        self.twitter_oauth2_redirect_uri: str | None = self.load(
+            "TWITTER_OAUTH2_REDIRECT_URI"
+        )
+        self.twitter_entrypoint_interval: int = self.load_int(
+            "TWITTER_ENTRYPOINT_INTERVAL", 5
+        )  # in minutes
+        # Slack Alert
+        self.slack_alert_token: str | None = self.load("SLACK_ALERT_TOKEN")
+        self.slack_alert_channel: str | None = self.load("SLACK_ALERT_CHANNEL")
+        # Skills - Platform Hosted Keys
+        self.acolyt_api_key: str | None = self.load("ACOLYT_API_KEY")
+        self.allora_api_key: str | None = self.load("ALLORA_API_KEY")
+        self.elfa_api_key: str | None = self.load("ELFA_API_KEY")
+        self.heurist_api_key: str | None = self.load("HEURIST_API_KEY")
+        self.enso_api_token: str | None = self.load("ENSO_API_TOKEN")
+        self.dapplooker_api_key: str | None = self.load("DAPPLOOKER_API_KEY")
+        self.moralis_api_key: str | None = self.load("MORALIS_API_KEY")
+        self.tavily_api_key: str | None = self.load("TAVILY_API_KEY")
+        self.cookiefun_api_key: str | None = self.load("COOKIEFUN_API_KEY")
+        self.firecrawl_api_key: str | None = self.load("FIRECRAWL_API_KEY")
+        # Sentry
+        self.sentry_dsn: str | None = self.load("SENTRY_DSN")
+        self.sentry_sample_rate: float = self.load_float("SENTRY_SAMPLE_RATE", 0.1)
+        self.sentry_traces_sample_rate: float = self.load_float(
+            "SENTRY_TRACES_SAMPLE_RATE", 0.01
+        )
+        self.sentry_profiles_sample_rate: float = self.load_float(
+            "SENTRY_PROFILES_SAMPLE_RATE", 0.01
+        )
+        # RPC Providers
+        self.quicknode_api_key: str | None = self.load("QUICKNODE_API_KEY")
+        self.chain_provider: ChainProvider | None = None
+        if self.quicknode_api_key:
+            self.chain_provider = QuicknodeChainProvider(self.quicknode_api_key)
+        if self.chain_provider:
+            self.chain_provider.init_chain_configs()
+
+        # Nation
+        self.nation_api_key: str | None = self.load("NATION_API_KEY")
+        self.nation_api_url: str = self.load("NATION_API_URL", "")
+
+        # ===== config loaded
+        # Now we know the env, set up logging
+        setup_logging(self.env, self.debug)
+        logger.info("config loaded")
+
+        # If the slack alert token exists, init it
+        if self.slack_alert_token and self.slack_alert_channel:
+            init_slack(self.slack_alert_token, self.slack_alert_channel)
+        # If the AWS S3 bucket and CDN URL exist, init it
+        if self.aws_s3_bucket and self.aws_s3_cdn_url:
+            init_s3(self.aws_s3_bucket, self.aws_s3_cdn_url, self.env)
+
+    @overload
+    def load(self, key: str) -> str | None: ...  # noqa: F811
+
+    @overload
+    def load(self, key: str, default: str) -> str: ...  # noqa: F811
+
+    def load(self, key: str, default: str | None = None) -> str | None:
+        """Load a secret from the secrets map or env"""
+        env_value = os.getenv(key, default)
+        raw_value = self.secrets.get(key, env_value)
+        if raw_value is None:
+            value: str | None = default
+        elif isinstance(raw_value, str):
+            value = raw_value
+        else:
+            value = str(raw_value)
+
+        # If value is empty string, use default instead
+        if value == "":
+            value = default
+
+        if value:
+            value = value.replace("\\n", "\n")
+        if value and value.startswith("'") and value.endswith("'"):
+            value = value[1:-1]
+        return value
+
+    def load_int(self, key: str, default: int = 0) -> int:
+        """Load an integer value from env, handling empty strings gracefully"""
+        value = self.load(key, str(default))
+        if not value:
+            return default
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            logger.warning(f"Invalid integer value for {key}, using default: {default}")
+            return default
+
+    def load_float(self, key: str, default: float = 0.0) -> float:
+        """Load a float value from env, handling empty strings gracefully"""
+        value = self.load(key, str(default))
+        if not value:
+            return default
+        try:
+            return float(value)
+        except (ValueError, TypeError):
+            logger.warning(f"Invalid float value for {key}, using default: {default}")
+            return default
+
+
+config: Config = Config()

{intentkit-0.8.17.dev2 → intentkit-0.8.27.dev1/intentkit}/core/asset.py

@@ -33,6 +33,14 @@ USDC_ADDRESSES = {
 # NATION token address for base-mainnet
 NATION_ADDRESS = "0x2f74f818e81685c8086dd783837a4605a90474b8"
 
+MORALIS_CHAIN_BY_NETWORK = {
+    "ethereum-mainnet": "eth",
+    "base-mainnet": "base",
+    "polygon-mainnet": "polygon",
+    "arbitrum-mainnet": "arbitrum",
+    "optimism-mainnet": "optimism",
+}
+
 
 class Asset(BaseModel):
     """Model for individual asset with symbol and balance."""
@@ -101,8 +109,12 @@ async def _get_eth_balance(web3_client: Web3, wallet_address: str) -> Decimal:
         return Decimal("0")
 
 
-async def _get_wallet_net_worth(wallet_address: str) -> str:
+async def _get_wallet_net_worth(wallet_address: str, network_id: str | None) -> str:
     """Get wallet net worth using Moralis API."""
+    moralis_chain = MORALIS_CHAIN_BY_NETWORK.get(network_id or "")
+    if not moralis_chain:
+        return "0"
+
     try:
         async with httpx.AsyncClient() as client:
             url = (
@@ -116,7 +128,7 @@ async def _get_wallet_net_worth(wallet_address: str) -> str:
             params = {
                 "exclude_spam": "true",
                 "exclude_unverified_contracts": "true",
-                "chains": ["eth", "base", "polygon", "arbitrum", "optimism"],
+                "chains": [moralis_chain],
             }
 
             response = await client.get(url, headers=headers, params=params)
@@ -206,7 +218,9 @@ async def agent_asset(agent_id: str) -> AgentAssets:
         try:
             web3_client = get_web3_client(str(agent.network_id))
             tokens = await _build_assets_list(agent, agent_data, web3_client)
-            net_worth = await _get_wallet_net_worth(agent_data.evm_wallet_address)
+            net_worth = await _get_wallet_net_worth(
+                agent_data.evm_wallet_address, str(agent.network_id)
+            )
             assets_result = AgentAssets(net_worth=net_worth, tokens=tokens)
         except IntentKitAPIError:
             raise

{intentkit-0.8.17.dev2 → intentkit-0.8.27.dev1/intentkit}/core/credit.py

@@ -1285,16 +1285,16 @@ async def skill_cost(
     skill = await Skill.get(skill_name)
     if not skill:
         raise ValueError(f"The price of {skill_name} not set yet")
-    agent_skill_config = agent.skills.get(skill.category)
-    if (
-        agent_skill_config
-        and agent_skill_config.get("api_key_provider") == "agent_owner"
-    ):
-        base_skill_amount = skill.price_self_key.quantize(
-            FOURPLACES, rounding=ROUND_HALF_UP
-        )
-    else:
-        base_skill_amount = skill.price.quantize(FOURPLACES, rounding=ROUND_HALF_UP)
+    base_skill_amount = skill.price.quantize(FOURPLACES, rounding=ROUND_HALF_UP)
+    if agent.skills:
+        agent_skill_config = agent.skills.get(skill.category)
+        if (
+            agent_skill_config
+            and agent_skill_config.get("api_key_provider") == "agent_owner"
+        ):
+            base_skill_amount = skill.price_self_key.quantize(
+                FOURPLACES, rounding=ROUND_HALF_UP
+            )
     # Get payment settings
     payment_settings = await AppSetting.payment()
 

{intentkit-0.8.17.dev2 → intentkit-0.8.27.dev1/intentkit}/core/engine.py

@@ -67,6 +67,29 @@ _agents: dict[str, CompiledStateGraph] = {}
 _agents_updated: dict[str, datetime] = {}
 
 
+def _extract_text_content(content: object) -> str:
+    if isinstance(content, list):
+        texts: list[str] = []
+        for item in content:
+            if isinstance(item, dict):
+                t = item.get("text")
+                ty = item.get("type")
+                if t is not None and (ty == "text" or ty is None):
+                    texts.append(t)
+            elif isinstance(item, str):
+                texts.append(item)
+        return "".join(texts)
+    if isinstance(content, dict):
+        if content.get("type") == "text" and "text" in content:
+            return content["text"]
+        if "text" in content:
+            return content["text"]
+        return ""
+    if isinstance(content, str):
+        return content
+    return ""
+
+
 async def build_agent(
     agent: Agent, agent_data: AgentData, custom_skills: list[BaseTool] = []
 ) -> CompiledStateGraph:
@@ -149,8 +172,8 @@ async def build_agent(
                 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.model_name == "gpt-5-mini":
+                        llm_params["reasoning_effort"] = "medium"
                 if llm_model.info.provider == LLMProvider.XAI:
                     llm_params["search_parameters"] = {"mode": "auto"}
             # TODO: else use a search skill
@@ -330,8 +353,6 @@ async def stream_agent_raw(
     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:
@@ -363,6 +384,7 @@ async def stream_agent_raw(
             AuthorType.TELEGRAM,
             AuthorType.TWITTER,
             AuthorType.API,
+            AuthorType.X402,
         ]:
             payer = agent.owner
         # user account
@@ -432,31 +454,30 @@ async def stream_agent_raw(
 
     # super mode
     recursion_limit = 30
-    if re.search(r"\b@super\b", input_message):
+    if re.search(r"@super\b", input_message) or user_message.super_mode:
         recursion_limit = 300
         # Remove @super from the message
-        input_message = re.sub(r"\b@super\b", "", input_message).strip()
+        input_message = re.sub(r"@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 = user_message.search_mode if user_message.search_mode is not None else False
+    if re.search(r"@search\b", input_message) or re.search(r"@web\b", input_message):
         search = True
         if model.supports_search:
             input_message = re.sub(
-                r"\b@search\b",
+                r"@search\b",
                 "(You have native search tool, you can use it to get more recent information)",
                 input_message,
             ).strip()
             input_message = re.sub(
-                r"\b@web\b",
+                r"@web\b",
                 "(You have native search tool, you can use it to get more recent information)",
                 input_message,
             ).strip()
         else:
-            input_message = re.sub(r"\b@search\b", "", input_message).strip()
-            input_message = re.sub(r"\b@web\b", "", input_message).strip()
+            search = False
+            input_message = re.sub(r"@search\b", "", input_message).strip()
+            input_message = re.sub(r"@web\b", "", input_message).strip()
 
     # content to llm
     messages = [
@@ -527,16 +548,7 @@ async def stream_agent_raw(
                     # tool calls, save for later use, if it is deleted by post_model_hook, will not be used.
                     cached_tool_step = msg
                 if hasattr(msg, "content") and msg.content:
-                    content = msg.content
-                    if isinstance(msg.content, list):
-                        # in new version, content item maybe a list
-                        content = msg.content[0]
-                    if isinstance(content, dict):
-                        if "text" in content:
-                            content = content["text"]
-                        else:
-                            content = str(content)
-                            logger.error(f"unexpected content type: {content}")
+                    content = _extract_text_content(msg.content)
                     # agent message
                     chat_message_create = ChatMessageCreate(
                         id=str(XID()),

{intentkit-0.8.17.dev2 → intentkit-0.8.27.dev1/intentkit}/core/prompt.py

@@ -250,7 +250,7 @@ async def explain_prompt(message: str) -> str:
         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)