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

intentkit/clients/twitter.py

@@ -1,8 +1,8 @@
 import logging
 import os
 import tempfile
-from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, List, NotRequired, Optional, TypedDict
+from datetime import UTC, datetime, timedelta
+from typing import Any, NotRequired, TypedDict
 from urllib.parse import urlencode
 
 import httpx
@@ -11,14 +11,17 @@ from requests.auth import HTTPBasicAuth
 from requests_oauthlib import OAuth2Session
 from tweepy.asynchronous import AsyncClient
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.abstracts.twitter import TwitterABC
 from intentkit.models.agent_data import AgentData
+from intentkit.models.redis import get_redis
 
 logger = logging.getLogger(__name__)
 
-_clients_linked: Dict[str, "TwitterClient"] = {}
-_clients_self_key: Dict[str, "TwitterClient"] = {}
+_clients_linked: dict[str, "TwitterClient"] = {}
+_clients_self_key: dict[str, "TwitterClient"] = {}
+
+_VERIFIER_KEY = "intentkit:twitter:code_verifier"
+_CHALLENGE_KEY = "intentkit:twitter:code_challenge"
 
 
 class TwitterMedia(BaseModel):
@@ -26,7 +29,7 @@ class TwitterMedia(BaseModel):
 
     media_key: str
     type: str
-    url: Optional[str] = None
+    url: str | None = None
 
 
 class TwitterUser(BaseModel):
@@ -55,10 +58,10 @@ class Tweet(BaseModel):
     id: str
     text: str
     author_id: str
-    author: Optional[TwitterUser] = None
+    author: TwitterUser | None = None
     created_at: datetime
-    referenced_tweets: Optional[List["Tweet"]] = None
-    attachments: Optional[List[TwitterMedia]] = None
+    referenced_tweets: list["Tweet"] | None = None
+    attachments: list[TwitterMedia] | None = None
 
 
 class TwitterClientConfig(TypedDict):
@@ -76,33 +79,44 @@ class TwitterClient(TwitterABC):
 
     Args:
         agent_id: The ID of the agent
-        skill_store: The skill store for retrieving data
         config: Configuration dictionary that may contain API keys
     """
 
-    def __init__(self, agent_id: str, skill_store: SkillStoreABC, config: Dict) -> None:
+    def __init__(self, agent_id: str, config: dict) -> None:
         """Initialize the Twitter client.
 
         Args:
             agent_id: The ID of the agent
-            skill_store: The skill store for retrieving data
             config: Configuration dictionary that may contain API keys
         """
         self.agent_id = agent_id
-        self._client: Optional[AsyncClient] = None
-        self._skill_store = skill_store
-        self._agent_data: Optional[AgentData] = None
+        self._client: AsyncClient | None = None
+        self._agent_data: AgentData | None = None
         self.use_key = _is_self_key(config)
         self._config = config
 
+    async def _get_agent_data(self) -> AgentData:
+        """Retrieve cached agent data, loading from the database if needed."""
+
+        if not self._agent_data:
+            self._agent_data = await AgentData.get(self.agent_id)
+        return self._agent_data
+
+    async def _refresh_agent_data(self) -> AgentData:
+        """Reload agent data from the database."""
+
+        self._agent_data = await AgentData.get(self.agent_id)
+        return self._agent_data
+
     async def get_client(self) -> AsyncClient:
         """Get the initialized Twitter client.
 
         Returns:
             AsyncClient: The Twitter client if initialized
         """
-        if not self._agent_data:
-            self._agent_data = await self._skill_store.get_agent_data(self.agent_id)
+
+        agent_data = await self._get_agent_data()
+
         if not self._client:
             # Check if we have API keys in config
             if self.use_key:
@@ -114,30 +128,26 @@ class TwitterClient(TwitterABC):
                     return_type=dict,
                 )
                 # refresh userinfo if needed
-                if not self._agent_data.twitter_self_key_refreshed_at or (
-                    self._agent_data.twitter_self_key_refreshed_at
-                    < datetime.now(tz=timezone.utc) - timedelta(days=1)
+                if not agent_data.twitter_self_key_refreshed_at or (
+                    agent_data.twitter_self_key_refreshed_at
+                    < datetime.now(tz=UTC) - timedelta(days=1)
                 ):
                     me = await self._client.get_me(
                         user_auth=self.use_key,
                         user_fields="id,username,name,verified",
                     )
                     if me and "data" in me and "id" in me["data"]:
-                        await self._skill_store.set_agent_data(
+                        await AgentData.patch(
                             self.agent_id,
                             {
                                 "twitter_id": me["data"]["id"],
                                 "twitter_username": me["data"]["username"],
                                 "twitter_name": me["data"]["name"],
                                 "twitter_is_verified": me["data"]["verified"],
-                                "twitter_self_key_refreshed_at": datetime.now(
-                                    tz=timezone.utc
-                                ),
+                                "twitter_self_key_refreshed_at": datetime.now(tz=UTC),
                             },
                         )
-                    self._agent_data = await self._skill_store.get_agent_data(
-                        self.agent_id
-                    )
+                    agent_data = await self._refresh_agent_data()
                 logger.info(
                     f"Twitter self key client initialized. "
                     f"Use API key: {self.use_key}, "
@@ -148,43 +158,38 @@ class TwitterClient(TwitterABC):
                 )
                 return self._client
             # Otherwise try to get OAuth2 tokens from agent data
-            if not self._agent_data.twitter_access_token:
+            if not agent_data.twitter_access_token:
                 raise Exception(f"[{self.agent_id}] Twitter access token not found")
-            if not self._agent_data.twitter_access_token_expires_at:
+            if not agent_data.twitter_access_token_expires_at:
                 raise Exception(
                     f"[{self.agent_id}] Twitter access token expiration not found"
                 )
-            if self._agent_data.twitter_access_token_expires_at <= datetime.now(
-                tz=timezone.utc
-            ):
+            if agent_data.twitter_access_token_expires_at <= datetime.now(tz=UTC):
                 raise Exception(f"[{self.agent_id}] Twitter access token has expired")
             self._client = AsyncClient(
-                bearer_token=self._agent_data.twitter_access_token,
+                bearer_token=agent_data.twitter_access_token,
                 return_type=dict,
             )
             return self._client
+
         if not self.use_key:
             # check if access token has expired
-            if self._agent_data.twitter_access_token_expires_at <= datetime.now(
-                tz=timezone.utc
-            ):
-                self._agent_data = await self._skill_store.get_agent_data(self.agent_id)
-                # check again
-                if self._agent_data.twitter_access_token_expires_at <= datetime.now(
-                    tz=timezone.utc
-                ):
+            if agent_data.twitter_access_token_expires_at <= datetime.now(tz=UTC):
+                agent_data = await self._refresh_agent_data()
+                if agent_data.twitter_access_token_expires_at <= datetime.now(tz=UTC):
                     raise Exception(
                         f"[{self.agent_id}] Twitter access token has expired"
                     )
                 self._client = AsyncClient(
-                    bearer_token=self._agent_data.twitter_access_token,
+                    bearer_token=agent_data.twitter_access_token,
                     return_type=dict,
                 )
                 return self._client
+
         return self._client
 
     @property
-    def self_id(self) -> Optional[str]:
+    def self_id(self) -> str | None:
         """Get the Twitter user ID.
 
         Returns:
@@ -197,7 +202,7 @@ class TwitterClient(TwitterABC):
         return self._agent_data.twitter_id
 
     @property
-    def self_username(self) -> Optional[str]:
+    def self_username(self) -> str | None:
         """Get the Twitter username.
 
         Returns:
@@ -210,7 +215,7 @@ class TwitterClient(TwitterABC):
         return self._agent_data.twitter_username
 
     @property
-    def self_name(self) -> Optional[str]:
+    def self_name(self) -> str | None:
         """Get the Twitter display name.
 
         Returns:
@@ -223,7 +228,7 @@ class TwitterClient(TwitterABC):
         return self._agent_data.twitter_name
 
     @property
-    def self_is_verified(self) -> Optional[bool]:
+    def self_is_verified(self) -> bool | None:
         """Get the Twitter account verification status.
 
         Returns:
@@ -235,14 +240,14 @@ class TwitterClient(TwitterABC):
             return None
         return self._agent_data.twitter_is_verified
 
-    def process_tweets_response(self, response: Dict[str, Any]) -> List[Tweet]:
+    def process_tweets_response(self, response: dict[str, Any]) -> list[Tweet]:
         """Process Twitter API response and convert it to a list of Tweet objects.
 
         Args:
             response: Raw Twitter API response containing tweets data and includes.
 
         Returns:
-            List[Tweet]: List of processed Tweet objects.
+            list[Tweet]: List of processed Tweet objects.
         """
         result = []
         if not response.get("data"):
@@ -334,7 +339,7 @@ class TwitterClient(TwitterABC):
 
         return result
 
-    async def upload_media(self, agent_id: str, image_url: str) -> List[str]:
+    async def upload_media(self, agent_id: str, image_url: str) -> list[str]:
         """Upload media to Twitter and return the media IDs.
 
         Args:
@@ -342,13 +347,13 @@ class TwitterClient(TwitterABC):
             image_url: The URL of the image to upload.
 
         Returns:
-            List[str]: A list of media IDs for the uploaded media.
+            list[str]: A list of media IDs for the uploaded media.
 
         Raises:
             ValueError: If there's an error uploading the media.
         """
         # Get agent data to access the token
-        agent_data = await self._skill_store.get_agent_data(agent_id)
+        agent_data = await AgentData.get(agent_id)
         if not agent_data.twitter_access_token:
             raise ValueError("Only linked X account can post media")
 
@@ -415,19 +420,17 @@ class TwitterClient(TwitterABC):
         return media_ids
 
 
-def _is_self_key(config: Dict) -> bool:
+def _is_self_key(config: dict) -> bool:
     return config.get("api_key_provider") == "agent_owner"
 
 
-def get_twitter_client(
-    agent_id: str, skill_store: SkillStoreABC, config: Dict
-) -> "TwitterClient":
+def get_twitter_client(agent_id: str, config: dict) -> "TwitterClient":
     if _is_self_key(config):
         if agent_id not in _clients_self_key:
-            _clients_self_key[agent_id] = TwitterClient(agent_id, skill_store, config)
+            _clients_self_key[agent_id] = TwitterClient(agent_id, config)
         return _clients_self_key[agent_id]
     if agent_id not in _clients_linked:
-        _clients_linked[agent_id] = TwitterClient(agent_id, skill_store, config)
+        _clients_linked[agent_id] = TwitterClient(agent_id, config)
     return _clients_linked[agent_id]
 
 
@@ -460,17 +463,33 @@ class OAuth2UserHandler(OAuth2Session):
             self.auth = HTTPBasicAuth(client_id, client_secret)
         else:
             self.auth = None
-        self.code_challenge = self._client.create_code_challenge(
-            self._client.create_code_verifier(128), "S256"
-        )
+        self.code_verifier = None
+        self.code_challenge = None
 
-    def get_authorization_url(self, agent_id: str, redirect_uri: str):
+    async def get_authorization_url(self, agent_id: str, redirect_uri: str):
         """Get the authorization URL to redirect the user to
 
         Args:
             agent_id: ID of the agent to authenticate
             redirect_uri: URI to redirect to after authorization
         """
+        if not self.code_challenge:
+            try:
+                kv = await get_redis()
+                self.code_verifier = await kv.get(_VERIFIER_KEY)
+                self.code_challenge = await kv.get(_CHALLENGE_KEY)
+                if not self.code_verifier or not self.code_challenge:
+                    self.code_verifier = self._client.create_code_verifier(128)
+                    self.code_challenge = self._client.create_code_challenge(
+                        self.code_verifier, "S256"
+                    )
+                    await kv.set(_VERIFIER_KEY, self.code_verifier)
+                    await kv.set(_CHALLENGE_KEY, self.code_challenge)
+            except Exception:
+                self.code_verifier = self._client.create_code_verifier(128)
+                self.code_challenge = self._client.create_code_challenge(
+                    self.code_verifier, "S256"
+                )
         state_params = {"agent_id": agent_id, "redirect_uri": redirect_uri}
         authorization_url, _ = self.authorization_url(
             "https://x.com/i/oauth2/authorize",
@@ -484,12 +503,14 @@ class OAuth2UserHandler(OAuth2Session):
         """After user has authorized the app, fetch access token with
         authorization response URL
         """
+        if not self.code_verifier or not self.code_challenge:
+            raise ValueError("Code verifier or challenge not init")
         return super().fetch_token(
             "https://api.x.com/2/oauth2/token",
             authorization_response=authorization_response,
             auth=self.auth,
             include_client_id=True,
-            code_verifier=self._client.code_verifier,
+            code_verifier=self.code_verifier,
         )
 
     def refresh(self, refresh_token: str):

intentkit/clients/web3.py

@@ -0,0 +1,29 @@
+from web3 import Web3
+
+from intentkit.config.config import config
+from intentkit.utils.chain import ChainProvider
+
+# Global cache for Web3 clients by network_id
+_web3_client_cache: dict[str, Web3] = {}
+
+
+def get_web3_client(network_id: str) -> Web3:
+    """Get a Web3 client for the specified network.
+
+    Args:
+        network_id: The network ID to get the Web3 client for
+
+    Returns:
+        Web3: A Web3 client instance for the specified network
+    """
+    # Check global cache first
+    if network_id in _web3_client_cache:
+        return _web3_client_cache[network_id]
+
+    # Create new Web3 client and cache it
+    chain_provider: ChainProvider = config.chain_provider
+    chain = chain_provider.get_chain_config(network_id)
+    web3_client = Web3(Web3.HTTPProvider(chain.rpc_url))
+    _web3_client_cache[network_id] = web3_client
+
+    return web3_client

intentkit/config/config.py

@@ -1,4 +1,3 @@
-# app/config.py
 import json
 import logging
 import os
@@ -78,14 +77,12 @@ class Config:
         self.debug_auth_enabled = self.load("DEBUG_AUTH_ENABLED", "false") == "true"
         self.debug_username = self.load("DEBUG_USERNAME")
         self.debug_password = self.load("DEBUG_PASSWORD")
-        self.admin_llm_skill_control = (
-            self.load("ADMIN_LLM_SKILL_CONTROL", "false") == "true"
-        )
         # Payment
         self.payment_enabled = self.load("PAYMENT_ENABLED", "false") == "true"
+        self.x402_fee_address = self.load("X402_FEE_ADDRESS")
         # Open API for agent
         self.open_api_base_url = self.load("OPEN_API_BASE_URL", "http://localhost:8000")
-        # CDP - AgentKit 0.6.0 Configuration
+        # CDP - AgentKit 0.7.x Configuration
         self.cdp_api_key_id = self.load("CDP_API_KEY_ID")
         self.cdp_api_key_secret = self.load("CDP_API_KEY_SECRET")
         self.cdp_wallet_secret = self.load("CDP_WALLET_SECRET")
@@ -96,8 +93,10 @@ class Config:
         self.eternal_api_key = self.load("ETERNAL_API_KEY")
         self.reigent_api_key = self.load("REIGENT_API_KEY")
         self.venice_api_key = self.load("VENICE_API_KEY")
+        self.gatewayz_api_key = self.load("GATEWAYZ_API_KEY")
         # LLM Config
         self.system_prompt = self.load("SYSTEM_PROMPT")
+        self.intentkit_prompt = self.load("INTENTKIT_PROMPT")
         self.input_token_limit = self.load_int("INPUT_TOKEN_LIMIT", 60000)
         # XMTP
         self.xmtp_system_prompt = self.load(
@@ -110,6 +109,10 @@ class Config:
         self.tg_server_host = self.load("TG_SERVER_HOST", "127.0.0.1")
         self.tg_server_port = self.load("TG_SERVER_PORT", "8081")
         self.tg_new_agent_poll_interval = self.load("TG_NEW_AGENT_POLL_INTERVAL", "60")
+        # Discord server settings
+        self.discord_new_agent_poll_interval = self.load(
+            "DISCORD_NEW_AGENT_POLL_INTERVAL", "30"
+        )
         # Twitter
         self.twitter_oauth2_client_id = self.load("TWITTER_OAUTH2_CLIENT_ID")
         self.twitter_oauth2_client_secret = self.load("TWITTER_OAUTH2_CLIENT_SECRET")