intentkit 0.6.0.dev6__py3-none-any.whl → 0.6.0.dev8__py3-none-any.whl

intentkit/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.6.0-dev.6"
+__version__ = "0.6.0-dev.8"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

intentkit/clients/cdp.py

@@ -1,9 +1,12 @@
+import json
+import logging
+import os
 from typing import Dict, Optional
 
-from cdp import Wallet
+from cdp import EvmServerAccount
 from coinbase_agentkit import (
-    CdpWalletProvider,
-    CdpWalletProviderConfig,
+    CdpEvmServerWalletProvider,
+    CdpEvmServerWalletProviderConfig,
 )
 
 from intentkit.abstracts.skill import SkillStoreABC
@@ -17,31 +20,80 @@ class CdpClient:
     def __init__(self, agent_id: str, skill_store: SkillStoreABC) -> None:
         self._agent_id = agent_id
         self._skill_store = skill_store
-        self._wallet_provider: Optional[CdpWalletProvider] = None
-        self._wallet_provider_config: Optional[CdpWalletProviderConfig] = None
+        self._wallet_provider: Optional[CdpEvmServerWalletProvider] = None
+        self._wallet_provider_config: Optional[CdpEvmServerWalletProviderConfig] = None
 
-    async def get_wallet_provider(self) -> CdpWalletProvider:
+    async def get_wallet_provider(self) -> CdpEvmServerWalletProvider:
         if self._wallet_provider:
             return self._wallet_provider
         agent: Agent = await self._skill_store.get_agent_config(self._agent_id)
         agent_data: AgentData = await self._skill_store.get_agent_data(self._agent_id)
         network_id = agent.network_id or agent.cdp_network_id
-        self._wallet_provider_config = CdpWalletProviderConfig(
-            api_key_name=self._skill_store.get_system_config("cdp_api_key_name"),
-            api_key_private_key=self._skill_store.get_system_config(
-                "cdp_api_key_private_key"
-            ),
+
+        logger = logging.getLogger(__name__)
+
+        # Collect credentials from system-config first, then env vars as fallback
+        api_key_id = (
+            self._skill_store.get_system_config("cdp_api_key_name")
+            or os.getenv("CDP_API_KEY_ID")
+            or os.getenv("CDP_API_KEY_NAME")
+        )
+
+        api_key_secret = (
+            self._skill_store.get_system_config("cdp_api_key_private_key")
+            or os.getenv("CDP_API_KEY_SECRET")
+            or os.getenv("CDP_API_KEY_PRIVATE_KEY")
+        )
+
+        wallet_secret = self._skill_store.get_system_config(
+            "cdp_wallet_secret"
+        ) or os.getenv("CDP_WALLET_SECRET")
+
+        address = None
+
+        # Attempt to override with any wallet-specific secret stored in wallet_data
+        if agent_data.cdp_wallet_data:
+            try:
+                wallet_data = json.loads(agent_data.cdp_wallet_data)
+                # Try to get address from the new format or fallback to old format
+                if "default_address_id" in wallet_data:
+                    address = wallet_data["default_address_id"]
+
+                # Prefer wallet_secret stored alongside the wallet data if present
+                if "wallet_secret" in wallet_data:
+                    wallet_secret = wallet_data["wallet_secret"]
+                elif "account_data" in wallet_data and wallet_data["account_data"]:
+                    # Some versions may nest the secret inside account_data
+                    wallet_secret = (
+                        wallet_data["account_data"].get("wallet_secret")
+                        or wallet_secret
+                    )
+            except json.JSONDecodeError:
+                logger.warning(
+                    "Invalid JSON in cdp_wallet_data for agent %s", self._agent_id
+                )
+
+        self._wallet_provider_config = CdpEvmServerWalletProviderConfig(
+            api_key_id=api_key_id,
+            api_key_secret=api_key_secret,
             network_id=network_id,
-            wallet_data=agent_data.cdp_wallet_data,
+            address=address,
+            wallet_secret=wallet_secret,
         )
-        self._wallet_provider = CdpWalletProvider(self._wallet_provider_config)
+        self._wallet_provider = CdpEvmServerWalletProvider(self._wallet_provider_config)
         return self._wallet_provider
 
-    async def get_wallet(self) -> Wallet:
+    async def get_account(self) -> EvmServerAccount:
+        """Get the account object from the wallet provider.
+
+        Returns:
+            EvmServerAccount: The account object that can be used for balance checks, transfers, etc.
+        """
         wallet_provider = await self.get_wallet_provider()
-        return wallet_provider._wallet
+        # Access the internal account object
+        return wallet_provider._account
 
-    async def get_provider_config(self) -> CdpWalletProviderConfig:
+    async def get_provider_config(self) -> CdpEvmServerWalletProviderConfig:
         if not self._wallet_provider_config:
             await self.get_wallet_provider()
         return self._wallet_provider_config

intentkit/skills/cdp/__init__.py

@@ -5,10 +5,9 @@ from typing import TypedDict
 from coinbase_agentkit import (
     AgentKit,
     AgentKitConfig,
-    CdpWalletProvider,
+    CdpEvmServerWalletProvider,
     basename_action_provider,
     cdp_api_action_provider,
-    cdp_wallet_action_provider,
     erc20_action_provider,
     morpho_action_provider,
     pyth_action_provider,
@@ -37,10 +36,6 @@ class SkillStates(TypedDict):
     WalletActionProvider_native_transfer: SkillState
     CdpApiActionProvider_address_reputation: SkillState
     CdpApiActionProvider_request_faucet_funds: SkillState
-    CdpWalletActionProvider_deploy_contract: SkillState
-    CdpWalletActionProvider_deploy_nft: SkillState
-    CdpWalletActionProvider_deploy_token: SkillState
-    CdpWalletActionProvider_trade: SkillState
     PythActionProvider_fetch_price: SkillState
     PythActionProvider_fetch_price_feed_id: SkillState
     BasenameActionProvider_register_basename: SkillState
@@ -97,15 +92,15 @@ async def get_skills(
 
     # Initialize CDP client
     cdp_client: CdpClient = await get_cdp_client(agent_id, store)
-    cdp_wallet_provider: CdpWalletProvider = await cdp_client.get_wallet_provider()
-    cdp_provider_config = await cdp_client.get_provider_config()
+    cdp_wallet_provider: CdpEvmServerWalletProvider = (
+        await cdp_client.get_wallet_provider()
+    )
     agent_kit = AgentKit(
         AgentKitConfig(
             wallet_provider=cdp_wallet_provider,
             action_providers=[
                 wallet_action_provider(),
-                cdp_api_action_provider(cdp_provider_config),
-                cdp_wallet_action_provider(cdp_provider_config),
+                cdp_api_action_provider(),
                 pyth_action_provider(),
                 basename_action_provider(),
                 erc20_action_provider(),
@@ -121,9 +116,11 @@ async def get_skills(
     tools = []
     for skill in available_skills:
         if skill == "get_balance":
+            # Get the account object for the custom GetBalance skill
+            account = await cdp_client.get_account()
             tools.append(
                 GetBalance(
-                    wallet=cdp_wallet_provider._wallet,
+                    account=account,
                     agent_id=agent_id,
                     skill_store=store,
                 )

intentkit/skills/cdp/get_balance.py

@@ -1,9 +1,10 @@
 from typing import Type
 
-from cdp import Wallet
+from cdp import EvmServerAccount
 from pydantic import BaseModel, Field
 
 from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.clients import get_cdp_client
 from intentkit.skills.cdp.base import CDPBaseTool
 
 
@@ -28,7 +29,7 @@ class GetBalance(CDPBaseTool):
 
     agent_id: str
     skill_store: SkillStoreABC
-    wallet: Wallet | None = None
+    account: EvmServerAccount | None = None
 
     name: str = "cdp_get_balance"
     description: str = (
@@ -48,25 +49,52 @@ class GetBalance(CDPBaseTool):
             str: A message containing the balance information or error message.
         """
         try:
-            if not self.wallet:
-                return "Failed to get wallet."
+            if not self.account:
+                return "Failed to get account."
+
+            # Get network information from CDP client
+            cdp_client = await get_cdp_client(self.agent_id, self.skill_store)
+            provider_config = await cdp_client.get_provider_config()
+            network_id = provider_config.network_id
+
+            # Map network_id to the format expected by the API
+            network_mapping = {
+                "base-mainnet": "base",
+                "base-sepolia": "base-sepolia",
+                "ethereum": "ethereum",
+                "ethereum-mainnet": "ethereum",
+            }
+            api_network = network_mapping.get(network_id, network_id)
+
+            # For native ETH balance, use the account's balance directly
+            if asset_id.lower() == "eth":
+                try:
+                    # Get native balance using Web3
+                    balance_wei = await self.account.get_balance()
+                    balance_eth = balance_wei / (10**18)  # Convert from wei to ETH
+                    return f"ETH balance for account {self.account.address}: {balance_eth} ETH"
+                except Exception as e:
+                    return f"Error getting ETH balance: {e!s}"
+
+            # For other tokens, try the list_token_balances API
+            try:
+                # list_token_balances returns all token balances for the account
+                token_balances = await self.account.list_token_balances(api_network)
 
-            # for each address in the wallet, get the balance for the asset
-            balances = {}
+                # Find the balance for the specific asset
+                target_balance = None
+                for balance in token_balances:
+                    if balance.asset_id.lower() == asset_id.lower():
+                        target_balance = balance
+                        break
+
+                if target_balance:
+                    return f"Balance for {asset_id} in account {self.account.address}: {target_balance.amount} {target_balance.asset_id}"
+                else:
+                    return f"No balance found for asset {asset_id} in account {self.account.address}"
 
-            try:
-                for address in self.wallet.addresses:
-                    balance = address.balance(asset_id)
-                    balances[address.address_id] = balance
             except Exception as e:
-                return f"Error getting balance for all addresses in the wallet: {e!s}"
-
-            # Format each balance entry on a new line
-            balance_lines = [
-                f"  {addr}: {balance}" for addr, balance in balances.items()
-            ]
-            formatted_balances = "\n".join(balance_lines)
-            return f"Balances for wallet {self.wallet.id}:\n{formatted_balances}"
+                return f"Error getting balance for account: {e!s}"
 
         except Exception as e:
             return f"Error getting balance: {str(e)}"

intentkit/skills/cdp/schema.json

@@ -193,70 +193,6 @@
           "description": "State for WalletActionProvider_native_transfer",
           "default": "private"
         },
-        "CdpWalletActionProvider_trade": {
-          "type": "string",
-          "title": "CDP Wallet Trade",
-          "enum": [
-            "disabled",
-            "public",
-            "private"
-          ],
-          "x-enum-title": [
-            "Disabled",
-            "Agent Owner + All Users",
-            "Agent Owner Only"
-          ],
-          "description": "State for CdpWalletActionProvider_trade",
-          "default": "private"
-        },
-        "CdpWalletActionProvider_deploy_nft": {
-          "type": "string",
-          "title": "Cdp Wallet Deploy Nft",
-          "enum": [
-            "disabled",
-            "public",
-            "private"
-          ],
-          "x-enum-title": [
-            "Disabled",
-            "Agent Owner + All Users",
-            "Agent Owner Only"
-          ],
-          "description": "State for CdpWalletActionProvider_deploy_nft",
-          "default": "disabled"
-        },
-        "CdpWalletActionProvider_deploy_token": {
-          "type": "string",
-          "title": "CDP Wallet Deploy Token",
-          "enum": [
-            "disabled",
-            "public",
-            "private"
-          ],
-          "x-enum-title": [
-            "Disabled",
-            "Agent Owner + All Users",
-            "Agent Owner Only"
-          ],
-          "description": "State for CdpWalletActionProvider_deploy_token",
-          "default": "disabled"
-        },
-        "CdpWalletActionProvider_deploy_contract": {
-          "type": "string",
-          "title": "CDP Wallet Deploy Contract",
-          "enum": [
-            "disabled",
-            "public",
-            "private"
-          ],
-          "x-enum-title": [
-            "Disabled",
-            "Agent Owner + All Users",
-            "Agent Owner Only"
-          ],
-          "description": "State for CdpWalletActionProvider_deploy_contract",
-          "default": "disabled"
-        },
         "CdpApiActionProvider_request_faucet_funds": {
           "type": "string",
           "title": "CDP Request Faucet Funds",

intentkit/skills/enso/base.py

@@ -1,6 +1,7 @@
 from typing import Optional, Type
 
-from cdp import Wallet
+from cdp import EvmServerAccount
+from coinbase_agentkit import CdpEvmServerWalletProvider
 from pydantic import BaseModel, Field
 
 from intentkit.abstracts.skill import SkillStoreABC
@@ -22,9 +23,31 @@ class EnsoBaseTool(IntentKitSkill):
         description="The skill store for persisting data"
     )
 
-    async def get_wallet(self, context: SkillContext) -> Optional[Wallet]:
+    async def get_account(self, context: SkillContext) -> Optional[EvmServerAccount]:
+        """Get the account object from the CDP client.
+
+        Args:
+            context: The skill context containing agent information.
+
+        Returns:
+            Optional[EvmServerAccount]: The account object if available.
+        """
+        client: CdpClient = await get_cdp_client(context.agent.id, self.skill_store)
+        return await client.get_account()
+
+    async def get_wallet_provider(
+        self, context: SkillContext
+    ) -> Optional[CdpEvmServerWalletProvider]:
+        """Get the wallet provider from the CDP client.
+
+        Args:
+            context: The skill context containing agent information.
+
+        Returns:
+            Optional[CdpEvmServerWalletProvider]: The wallet provider if available.
+        """
         client: CdpClient = await get_cdp_client(context.agent.id, self.skill_store)
-        return await client.get_wallet()
+        return await client.get_wallet_provider()
 
     def get_chain_provider(self, context: SkillContext) -> Optional[ChainProvider]:
         return self.skill_store.get_system_config("chain_provider")

intentkit/skills/enso/route.py

@@ -6,9 +6,7 @@ from langchain_core.runnables import RunnableConfig
 from pydantic import BaseModel, Field
 
 from intentkit.skills.base import SkillContext
-from intentkit.skills.enso.abi.route import ABI_ROUTE
 from intentkit.skills.enso.networks import EnsoGetNetworks
-from intentkit.utils.tx import EvmContractWrapper
 
 from .base import EnsoBaseTool, base_url, default_chain_id
 
@@ -188,8 +186,7 @@ class EnsoRouteShortcut(EnsoBaseTool):
         context: SkillContext = self.context_from_config(config)
         agent_id = context.agent.id
         api_token = self.get_api_token(context)
-        chain_provider = self.get_chain_provider(context)
-        wallet = await self.get_wallet(context)
+        account = await self.get_account(context)
 
         async with httpx.AsyncClient() as client:
             try:
@@ -254,7 +251,7 @@ class EnsoRouteShortcut(EnsoBaseTool):
                     tokenOut=tokenOut,
                 ).model_dump(exclude_none=True)
 
-                params["fromAddress"] = wallet.addresses[0].address_id
+                params["fromAddress"] = account.address
 
                 response = await client.get(url, headers=headers, params=params)
                 response.raise_for_status()  # Raise HTTPError for non-2xx responses
@@ -268,23 +265,27 @@ class EnsoRouteShortcut(EnsoBaseTool):
                 )
 
                 if broadcast_requested:
-                    rpc_url = chain_provider.get_chain_config_by_id(chainId).rpc_url
-                    contract = EvmContractWrapper(
-                        rpc_url, ABI_ROUTE, json_dict.get("tx")
-                    )
-
-                    fn, fn_args = contract.fn_and_args
-
-                    fn_args["amountIn"] = str(fn_args["amountIn"])
-
-                    invocation = wallet.invoke_contract(
-                        contract_address=contract.dst_addr,
-                        method=fn.fn_name,
-                        abi=ABI_ROUTE,
-                        args=fn_args,
-                    ).wait()
-
-                    res.txHash = invocation.transaction.transaction_hash
+                    # Use the wallet provider to send the transaction
+                    wallet_provider = await self.get_wallet_provider(context)
+
+                    # Extract transaction data from the Enso API response
+                    tx_data = json_dict.get("tx", {})
+                    if tx_data:
+                        # Send the transaction using the wallet provider
+                        tx_hash = wallet_provider.send_transaction(
+                            {
+                                "to": tx_data.get("to"),
+                                "data": tx_data.get("data", "0x"),
+                                "value": tx_data.get("value", 0),
+                            }
+                        )
+
+                        # Wait for transaction confirmation
+                        wallet_provider.wait_for_transaction_receipt(tx_hash)
+                        res.txHash = tx_hash
+                    else:
+                        # For now, return a placeholder transaction hash if no tx data
+                        res.txHash = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
                 return res
 

intentkit/skills/enso/wallet.py

@@ -6,9 +6,7 @@ from langchain_core.runnables import RunnableConfig
 from pydantic import BaseModel, Field
 
 from intentkit.skills.base import SkillContext
-from intentkit.utils.tx import EvmContractWrapper
 
-from .abi.erc20 import ABI_ERC20
 from .base import EnsoBaseTool, base_url, default_chain_id
 
 
@@ -81,14 +79,14 @@ class EnsoGetWalletBalances(EnsoBaseTool):
 
         context: SkillContext = self.context_from_config(config)
         api_token = self.get_api_token(context)
-        wallet = await self.get_wallet(context)
+        account = await self.get_account(context)
         headers = {
             "accept": "application/json",
             "Authorization": f"Bearer {api_token}",
         }
 
         params = EnsoGetBalancesInput(chainId=chainId).model_dump(exclude_none=True)
-        params["eoaAddress"] = wallet.addresses[0].address_id
+        params["eoaAddress"] = account.address
         params["useEoa"] = True
 
         async with httpx.AsyncClient() as client:
@@ -178,7 +176,7 @@ class EnsoGetWalletApprovals(EnsoBaseTool):
 
         context: SkillContext = self.context_from_config(config)
         api_token = self.get_api_token(context)
-        wallet = await self.get_wallet(context)
+        account = await self.get_account(context)
 
         headers = {
             "accept": "application/json",
@@ -187,7 +185,7 @@ class EnsoGetWalletApprovals(EnsoBaseTool):
 
         params = EnsoGetApprovalsInput(
             chainId=chainId,
-            fromAddress=wallet.addresses[0].address_id,
+            fromAddress=account.address,
         )
 
         if kwargs.get("routingStrategy"):
@@ -318,15 +316,14 @@ class EnsoWalletApprove(EnsoBaseTool):
         url = f"{base_url}/api/v1/wallet/approve"
         context: SkillContext = self.context_from_config(config)
         api_token = self.get_api_token(context)
-        chain_provider = self.get_chain_provider(context)
-        wallet = await self.get_wallet(context)
+        account = await self.get_account(context)
 
         headers = {
             "accept": "application/json",
             "Authorization": f"Bearer {api_token}",
         }
 
-        from_address = wallet.addresses[0].address_id
+        from_address = account.address
 
         params = EnsoWalletApproveInput(
             tokenAddress=tokenAddress,
@@ -352,20 +349,27 @@ class EnsoWalletApprove(EnsoBaseTool):
                 content = EnsoWalletApproveOutput(**json_dict)
                 artifact = EnsoWalletApproveArtifact(**json_dict)
 
-                rpc_url = chain_provider.get_chain_config_by_id(chainId).rpc_url
-                contract = EvmContractWrapper(rpc_url, ABI_ERC20, artifact.tx)
-
-                fn, fn_args = contract.fn_and_args
-                fn_args["value"] = str(fn_args["value"])
-
-                invocation = wallet.invoke_contract(
-                    contract_address=contract.dst_addr,
-                    method=fn.fn_name,
-                    abi=ABI_ERC20,
-                    args=fn_args,
-                ).wait()
-
-                artifact.txHash = invocation.transaction.transaction_hash
+                # Use the wallet provider to send the transaction
+                wallet_provider = await self.get_wallet_provider(context)
+
+                # Extract transaction data from the Enso API response
+                tx_data = json_dict.get("tx", {})
+                if tx_data:
+                    # Send the transaction using the wallet provider
+                    tx_hash = wallet_provider.send_transaction(
+                        {
+                            "to": tx_data.get("to"),
+                            "data": tx_data.get("data", "0x"),
+                            "value": tx_data.get("value", 0),
+                        }
+                    )
+
+                    # Wait for transaction confirmation
+                    wallet_provider.wait_for_transaction_receipt(tx_hash)
+                    artifact.txHash = tx_hash
+                else:
+                    # For now, return without executing the transaction if no tx data
+                    artifact.txHash = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
                 # Return the parsed response
                 return (content, artifact)

intentkit/skills/web_scraper/README.md

@@ -10,12 +10,22 @@ Scrape content from URLs and index into a searchable vector store with configura
 ### 🔎 `query_indexed_content`
 Search indexed content using semantic similarity to answer questions and retrieve relevant information.
 
+### `website_indexer`
+Index entire websites by discovering and scraping all pages using sitemaps. Automatically finds sitemaps from robots.txt, extracts all URLs, and comprehensively indexes website content.
+
+### `document_indexer`
+Import and index document content directly to the vector database. Perfect for adding content from Google Docs, Notion pages, PDFs, or any other document sources by copy-pasting.
+
 ## Key Features
 
-- **Multi-URL Support**: Scrape up to 10 URLs simultaneously
+- **Multi-URL Support**: Scrape up to 10 URLs simultaneously 
+- **Sitemap Discovery**: Automatic sitemap detection from robots.txt with common patterns
+- **Direct Text Input**: Add content directly without web scraping
 - **Smart Chunking**: Configurable text splitting (100-4000 chars) with overlap
 - **Vector Search**: FAISS + OpenAI embeddings for semantic retrieval
 - **Agent Storage**: Persistent, per-agent content indexing
+- **Content Filtering**: Include/exclude URL patterns for targeted scraping
+- **Tagging System**: Organize content with custom tags
 - **Rate Limiting**: Respectful scraping (0.1-10 req/sec)
 
 ## Testing Examples
@@ -39,7 +49,27 @@ Please scrape and index this URL: https://docs.crestal.network/introduction
 Scrape and index https://docs.crestal.network/introduction with chunk size 500 and overlap 100.
 ```
 
-### 3. Content Querying
+### 3. Complete Website Indexing
+
+**Agent Prompt:**
+```
+Index the entire documentation site at https://docs.crestal.network using its sitemap. Include only pages with '/docs/' and '/guides/' in the URL, exclude '/admin/' pages, and limit to 50 URLs.
+```
+
+### 4. Document Content Import
+
+**Agent Prompt:**
+```
+I'm going to paste some content from my Google Doc. Please add it to the knowledge base:
+
+Title: "Meeting Notes - Q4 Strategy"
+Source: "Google Docs"
+Tags: "meeting, strategy, q4, planning"
+
+[Paste your document content here...]
+```
+
+### 5. Content Querying
 
 **Agent Prompt (after indexing):**
 ```
@@ -75,8 +105,9 @@ curl -X POST "http://localhost:8000/agents/your-agent-id/chat" \
 ## Dependencies
 
 Required packages (add to `pyproject.toml` if missing):
-- `langchain-community` - WebBaseLoader
+- `langchain-community` - WebBaseLoader and document processing
 - `langchain-openai` - Embeddings
 - `langchain-text-splitters` - Document chunking  
 - `faiss-cpu` - Vector storage
-- `beautifulsoup4` - HTML parsing
+- `beautifulsoup4` - HTML parsing
+- `httpx` - Async HTTP client for sitemap discovery

intentkit/skills/web_scraper/__init__.py

@@ -6,10 +6,12 @@ from typing import TypedDict
 from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillOwnerState, SkillState
 from intentkit.skills.web_scraper.base import WebScraperBaseTool
+from intentkit.skills.web_scraper.document_indexer import DocumentIndexer
 from intentkit.skills.web_scraper.scrape_and_index import (
     QueryIndexedContent,
     ScrapeAndIndex,
 )
+from intentkit.skills.web_scraper.website_indexer import WebsiteIndexer
 
 # Cache skills at the system level, because they are stateless
 _cache: dict[str, WebScraperBaseTool] = {}
@@ -20,6 +22,8 @@ logger = logging.getLogger(__name__)
 class SkillStates(TypedDict):
     scrape_and_index: SkillOwnerState
     query_indexed_content: SkillState
+    website_indexer: SkillOwnerState
+    document_indexer: SkillOwnerState
 
 
 class Config(SkillConfig):
@@ -87,6 +91,18 @@ def get_web_scraper_skill(
                 skill_store=store,
             )
         return _cache[name]
+    elif name == "website_indexer":
+        if name not in _cache:
+            _cache[name] = WebsiteIndexer(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "document_indexer":
+        if name not in _cache:
+            _cache[name] = DocumentIndexer(
+                skill_store=store,
+            )
+        return _cache[name]
     else:
         logger.warning(f"Unknown web scraper skill: {name}")
         return None