intentkit 0.8.12rc0__py3-none-any.whl → 0.8.13.dev2__py3-none-any.whl

intentkit/skills/web_scraper/utils.py

@@ -17,7 +17,7 @@ from langchain_core.documents import Document
 from langchain_openai import OpenAIEmbeddings
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 
-from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.config.config import config
 from intentkit.models.skill import AgentSkillData, AgentSkillDataCreate
 
 logger = logging.getLogger(__name__)
@@ -63,12 +63,20 @@ METADATA_KEY_PREFIX = "indexed_urls"
 class VectorStoreManager:
     """Manages vector store operations including creation, saving, loading, and merging."""
 
-    def __init__(self, skill_store: SkillStoreABC):
-        self.skill_store = skill_store
+    def __init__(self, embedding_api_key: Optional[str] = None):
+        self._embedding_api_key = embedding_api_key
+
+    def _resolve_api_key(self) -> str:
+        """Resolve the OpenAI API key to use for embeddings."""
+        if self._embedding_api_key:
+            return self._embedding_api_key
+        if config.openai_api_key:
+            return config.openai_api_key
+        raise ValueError("OpenAI API key is not configured")
 
     def create_embeddings(self) -> OpenAIEmbeddings:
-        """Create OpenAI embeddings using system API key."""
-        api_key = self.skill_store.get_system_config("openai_api_key")
+        """Create OpenAI embeddings using the resolved API key."""
+        api_key = self._resolve_api_key()
         return OpenAIEmbeddings(api_key=api_key)
 
     def get_storage_keys(self, agent_id: str) -> Tuple[str, str]:
@@ -226,7 +234,8 @@ class VectorStoreManager:
 
         return total_size
 
-    def format_size(self, size_bytes: int) -> str:
+    @staticmethod
+    def format_size(size_bytes: int) -> str:
         """Format size in bytes to human readable format."""
         if size_bytes < 1024:
             return f"{size_bytes} B"
@@ -312,13 +321,12 @@ class DocumentProcessor:
 class MetadataManager:
     """Manages metadata for indexed content."""
 
-    def __init__(self, skill_store: SkillStoreABC):
-        self.skill_store = skill_store
+    def __init__(self, vector_manager: VectorStoreManager):
+        self._vector_manager = vector_manager
 
     async def get_existing_metadata(self, agent_id: str) -> Dict:
         """Get existing metadata for an agent."""
-        vs_manager = VectorStoreManager(self.skill_store)
-        _, metadata_key = vs_manager.get_storage_keys(agent_id)
+        _, metadata_key = self._vector_manager.get_storage_keys(agent_id)
         return await AgentSkillData.get(agent_id, "web_scraper", metadata_key) or {}
 
     def create_url_metadata(
@@ -376,8 +384,7 @@ class MetadataManager:
 
     async def update_metadata(self, agent_id: str, new_metadata: Dict) -> None:
         """Update metadata for an agent."""
-        vs_manager = VectorStoreManager(self.skill_store)
-        _, metadata_key = vs_manager.get_storage_keys(agent_id)
+        _, metadata_key = self._vector_manager.get_storage_keys(agent_id)
 
         # Get existing metadata
         existing_metadata = await self.get_existing_metadata(agent_id)
@@ -453,9 +460,8 @@ class ResponseFormatter:
 
         # Add size information
         if current_size_bytes > 0:
-            vs_manager = VectorStoreManager(None)  # Just for formatting
-            formatted_size = vs_manager.format_size(current_size_bytes)
-            max_size = vs_manager.format_size(MAX_CONTENT_SIZE_BYTES)
+            formatted_size = VectorStoreManager.format_size(current_size_bytes)
+            max_size = VectorStoreManager.format_size(MAX_CONTENT_SIZE_BYTES)
             response_parts.append(
                 f"Current storage size: {formatted_size} / {max_size}"
             )
@@ -477,7 +483,7 @@ class ResponseFormatter:
 async def scrape_and_index_urls(
     urls: List[str],
     agent_id: str,
-    skill_store: SkillStoreABC,
+    vector_manager: VectorStoreManager,
     chunk_size: int = DEFAULT_CHUNK_SIZE,
     chunk_overlap: int = DEFAULT_CHUNK_OVERLAP,
     requests_per_second: int = DEFAULT_REQUESTS_PER_SECOND,
@@ -488,7 +494,7 @@ async def scrape_and_index_urls(
     Args:
         urls: List of URLs to scrape
         agent_id: Agent identifier for storage
-        skill_store: Skill store instance
+        vector_manager: Manager for vector store operations
         chunk_size: Size of text chunks
         chunk_overlap: Overlap between chunks
         requests_per_second: Rate limiting for requests
@@ -516,16 +522,15 @@ async def scrape_and_index_urls(
         return 0, False, []
 
     # Check existing content size
-    vs_manager = VectorStoreManager(skill_store)
-    current_size = await vs_manager.get_content_size(agent_id)
+    current_size = await vector_manager.get_content_size(agent_id)
 
     logger.info(
-        f"[{agent_id}] Current storage size: {vs_manager.format_size(current_size)}"
+        f"[{agent_id}] Current storage size: {VectorStoreManager.format_size(current_size)}"
     )
 
     if current_size >= MAX_CONTENT_SIZE_BYTES:
         logger.warning(
-            f"[{agent_id}] Storage limit already reached: {vs_manager.format_size(current_size)}"
+            f"[{agent_id}] Storage limit already reached: {VectorStoreManager.format_size(current_size)}"
         )
         return 0, False, []
 
@@ -595,7 +600,7 @@ async def scrape_and_index_urls(
 
             # Process and index this URL's content
             chunks, merged = await index_documents(
-                documents, agent_id, skill_store, chunk_size, chunk_overlap
+                documents, agent_id, vector_manager, chunk_size, chunk_overlap
             )
 
             if chunks > 0:
@@ -605,7 +610,7 @@ async def scrape_and_index_urls(
                 current_size += content_size
 
                 logger.info(
-                    f"[{agent_id}] Processed {url}: {chunks} chunks, current size: {vs_manager.format_size(current_size)}"
+                    f"[{agent_id}] Processed {url}: {chunks} chunks, current size: {VectorStoreManager.format_size(current_size)}"
                 )
 
             # Add delay for rate limiting
@@ -633,7 +638,7 @@ async def scrape_and_index_urls(
 async def index_documents(
     documents: List[Document],
     agent_id: str,
-    skill_store: SkillStoreABC,
+    vector_manager: VectorStoreManager,
     chunk_size: int = DEFAULT_CHUNK_SIZE,
     chunk_overlap: int = DEFAULT_CHUNK_OVERLAP,
 ) -> Tuple[int, bool]:
@@ -650,13 +655,12 @@ async def index_documents(
         raise ValueError("No content could be processed into chunks")
 
     # Handle vector store
-    vs_manager = VectorStoreManager(skill_store)
-    vector_store, was_merged = await vs_manager.merge_with_existing(
+    vector_store, was_merged = await vector_manager.merge_with_existing(
         split_docs, agent_id, chunk_size, chunk_overlap
     )
 
     # Save vector store
-    await vs_manager.save_vector_store(
+    await vector_manager.save_vector_store(
         vector_store, agent_id, chunk_size, chunk_overlap
     )
 

intentkit/skills/web_scraper/website_indexer.py

@@ -250,10 +250,7 @@ Extract the URLs now:"""
         """Call OpenAI GPT-4o-mini to extract URLs from sitemap content."""
         try:
             # Get OpenAI API key using the standard pattern
-            from intentkit.skills.openai.base import OpenAIBaseTool
-
-            temp_tool = OpenAIBaseTool(skill_store=self.skill_store)
-            api_key = temp_tool.get_api_key()
+            api_key = self.get_openai_api_key()
 
             # Initialize OpenAI client
             client = openai.AsyncOpenAI(api_key=api_key)
@@ -385,9 +382,12 @@ Extract the URLs now:"""
                 f"[{agent_id}] Extracted {len(unique_urls)} URLs from sitemaps. Scraping and indexing..."
             )
 
+            embedding_api_key = self.get_openai_api_key()
+            vector_manager = VectorStoreManager(embedding_api_key)
+
             # Use the utility function to scrape and index URLs directly
             total_chunks, was_merged, valid_urls = await scrape_and_index_urls(
-                unique_urls, agent_id, self.skill_store, chunk_size, chunk_overlap
+                unique_urls, agent_id, vector_manager, chunk_size, chunk_overlap
             )
 
             if total_chunks == 0:
@@ -397,12 +397,11 @@ Extract the URLs now:"""
                 return f"Error: No content could be extracted from the discovered URLs. Found sitemaps: {', '.join(found_sitemaps)}"
 
             # Get current storage size for response
-            vs_manager = VectorStoreManager(self.skill_store)
-            current_size = await vs_manager.get_content_size(agent_id)
+            current_size = await vector_manager.get_content_size(agent_id)
             size_limit_reached = len(valid_urls) < len(unique_urls)
 
             # Update metadata
-            metadata_manager = MetadataManager(self.skill_store)
+            metadata_manager = MetadataManager(vector_manager)
             new_metadata = metadata_manager.create_url_metadata(
                 valid_urls, [], "website_indexer"
             )

intentkit/skills/weth/__init__.py

@@ -4,7 +4,6 @@ from typing import TYPE_CHECKING, Optional, TypedDict
 
 from coinbase_agentkit import weth_action_provider
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import (
     SkillConfig,
     SkillState,
@@ -30,7 +29,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     agent_id: str,
     agent: Optional["Agent"] = None,
     **_,
@@ -44,9 +42,7 @@ async def get_skills(
         if state == "public" or (state == "private" and is_private):
             available_skills.append(skill_name)
 
-    actions = await get_agentkit_actions(
-        agent_id, store, [weth_action_provider], agent=agent
-    )
+    actions = await get_agentkit_actions(agent_id, [weth_action_provider], agent=agent)
     tools: list[WethBaseTool] = []
     for skill in available_skills:
         for action in actions:

intentkit/skills/wow/__init__.py

@@ -4,7 +4,6 @@ from typing import TYPE_CHECKING, Optional, TypedDict
 
 from coinbase_agentkit import wow_action_provider
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import (
     SkillConfig,
     SkillState,
@@ -32,7 +31,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     agent_id: str,
     agent: Optional["Agent"] = None,
     **_,
@@ -46,9 +44,7 @@ async def get_skills(
         if state == "public" or (state == "private" and is_private):
             available_skills.append(skill_name)
 
-    actions = await get_agentkit_actions(
-        agent_id, store, [wow_action_provider], agent=agent
-    )
+    actions = await get_agentkit_actions(agent_id, [wow_action_provider], agent=agent)
     tools: list[WowBaseTool] = []
     for skill in available_skills:
         for action in actions:

intentkit/skills/x402/__init__.py

@@ -0,0 +1,53 @@
+"""x402 skill category."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.x402.ask_agent import X402AskAgent
+from intentkit.skills.x402.base import X402BaseSkill
+
+logger = logging.getLogger(__name__)
+
+_cache: dict[str, X402BaseSkill] = {}
+
+
+class SkillStates(TypedDict):
+    x402_ask_agent: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for x402 skills."""
+
+    states: SkillStates
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    **_,
+) -> list[X402BaseSkill]:
+    """Return enabled x402 skills for the agent."""
+    enabled_skills = []
+    for skill_name, state in config["states"].items():
+        if state == "disabled":
+            continue
+        if state == "public" or (state == "private" and is_private):
+            enabled_skills.append(skill_name)
+
+    result: list[X402BaseSkill] = []
+    for name in enabled_skills:
+        skill = _get_skill(name)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def _get_skill(name: str) -> X402BaseSkill | None:
+    if name == "x402_ask_agent":
+        if name not in _cache:
+            _cache[name] = X402AskAgent()
+        return _cache[name]
+
+    logger.warning("Unknown x402 skill requested: %s", name)
+    return None

intentkit/skills/x402/ask_agent.py

@@ -0,0 +1,82 @@
+from typing import Any, Dict, Optional, Type
+
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+from x402.clients.httpx import x402HttpxClient
+
+from intentkit.config.config import config
+from intentkit.models.chat import AuthorType
+from intentkit.skills.x402.base import X402BaseSkill
+
+
+class AskAgentInput(BaseModel):
+    """Arguments for the x402 ask agent skill."""
+
+    agent_id: str = Field(description="ID or slug of the agent to query.")
+    message: str = Field(description="Message to send to the target agent.")
+    search_mode: Optional[bool] = Field(
+        default=None, description="Enable search mode when interacting with the agent."
+    )
+    super_mode: Optional[bool] = Field(
+        default=None, description="Enable super mode when interacting with the agent."
+    )
+
+
+class X402AskAgent(X402BaseSkill):
+    """Skill that queries another agent via the x402 API."""
+
+    name: str = "x402_ask_agent"
+    description: str = (
+        "Call another agent through the x402 API and return the final agent message."
+    )
+    args_schema: Type[BaseModel] = AskAgentInput
+
+    async def _arun(
+        self,
+        agent_id: str,
+        message: str,
+        search_mode: Optional[bool] = None,
+        super_mode: Optional[bool] = None,
+    ) -> str:
+        base_url = (config.open_api_base_url or "").rstrip("/")
+        if not base_url:
+            raise ValueError("X402 API base URL is not configured.")
+
+        # Ensure an EVM account exists and retrieve wallet provider signer
+        evm_account = await self.get_evm_account()
+
+        payload: Dict[str, Any] = {
+            "agent_id": agent_id,
+            "message": message,
+            "app_id": "skill",
+        }
+        if search_mode is not None:
+            payload["search_mode"] = search_mode
+        if super_mode is not None:
+            payload["super_mode"] = super_mode
+
+        async with x402HttpxClient(
+            account=evm_account,
+            base_url=base_url,
+            timeout=20.0,
+        ) as client:
+            response = await client.post("/x402", json=payload)
+            response.raise_for_status()
+            messages = response.json()
+        if not isinstance(messages, list) or not messages:
+            raise ValueError("Agent returned an empty response.")
+
+        last_message = messages[-1]
+        if not isinstance(last_message, dict):
+            raise ValueError("Agent response format is invalid.")
+
+        author_type = last_message.get("author_type")
+        content = last_message.get("message")
+
+        if author_type == AuthorType.SYSTEM.value:
+            raise ToolException(content or "Agent returned a system message.")
+
+        if not content:
+            raise ToolException("Agent response did not include message text.")
+
+        return str(content)

intentkit/skills/x402/base.py

@@ -0,0 +1,9 @@
+from intentkit.skills.onchain import IntentKitOnChainSkill
+
+
+class X402BaseSkill(IntentKitOnChainSkill):
+    """Base class for x402 skills."""
+
+    @property
+    def category(self) -> str:
+        return "x402"

intentkit/skills/x402/schema.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "x402",
+  "description": "Interact with other IntentKit agents through the x402 payment protocol.",
+  "x-icon": "https://ai.service.crestal.dev/skills/x402/x402.png",
+  "x-tags": [
+    "Communication",
+    "Infrastructure"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill category is enabled.",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "x402_ask_agent": {
+          "type": "string",
+          "title": "Ask Agent",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Send a message to another IntentKit agent via the x402 API and return the final agent response.",
+          "default": "disabled"
+        }
+      }
+    }
+  }
+}

intentkit/skills/xmtp/__init__.py

@@ -3,7 +3,6 @@
 import logging
 from typing import TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.xmtp.base import XmtpBaseTool
 from intentkit.skills.xmtp.price import XmtpGetSwapPrice
@@ -31,7 +30,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     **_,
 ) -> list[XmtpBaseTool]:
     """Get all XMTP skills.
@@ -39,7 +37,6 @@ async def get_skills(
     Args:
         config: The configuration for XMTP skills.
         is_private: Whether to include private skills.
-        store: The skill store for persisting data.
 
     Returns:
         A list of XMTP skills.
@@ -56,7 +53,7 @@ async def get_skills(
     # Get each skill using the cached getter
     result = []
     for name in available_skills:
-        skill = get_xmtp_skill(name, store)
+        skill = get_xmtp_skill(name)
         if skill:
             result.append(skill)
     return result
@@ -64,34 +61,26 @@ async def get_skills(
 
 def get_xmtp_skill(
     name: str,
-    store: SkillStoreABC,
 ) -> XmtpBaseTool:
     """Get an XMTP skill by name.
 
     Args:
         name: The name of the skill to get
-        store: The skill store for persisting data
 
     Returns:
         The requested XMTP skill
     """
     if name == "xmtp_transfer":
         if name not in _cache:
-            _cache[name] = XmtpTransfer(
-                skill_store=store,
-            )
+            _cache[name] = XmtpTransfer()
         return _cache[name]
     elif name == "xmtp_swap":
         if name not in _cache:
-            _cache[name] = XmtpSwap(
-                skill_store=store,
-            )
+            _cache[name] = XmtpSwap()
         return _cache[name]
     elif name == "xmtp_get_swap_price":
         if name not in _cache:
-            _cache[name] = XmtpGetSwapPrice(
-                skill_store=store,
-            )
+            _cache[name] = XmtpGetSwapPrice()
         return _cache[name]
     else:
         logger.warning(f"Unknown XMTP skill: {name}")

intentkit/skills/xmtp/base.py

@@ -1,9 +1,9 @@
 from typing import Dict, Literal
 
-from intentkit.skills.base import IntentKitSkill
+from intentkit.skills.onchain import IntentKitOnChainSkill
 
 
-class XmtpBaseTool(IntentKitSkill):
+class XmtpBaseTool(IntentKitOnChainSkill):
     """Base class for XMTP-related skills."""
 
     # Set response format to content_and_artifact for returning tuple

intentkit/skills/xmtp/price.py

@@ -3,7 +3,7 @@ from typing import Literal, Type
 from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
-from intentkit.clients.cdp import get_origin_cdp_client
+from intentkit.clients.cdp import get_cdp_client
 from intentkit.skills.xmtp.base import XmtpBaseTool
 
 
@@ -50,8 +50,8 @@ class XmtpGetSwapPrice(XmtpBaseTool):
 
         network_for_cdp = self.get_cdp_network(agent.network_id)
 
-        cdp_client = get_origin_cdp_client()
-        # Note: Don't use async with context manager as get_origin_cdp_client returns a managed global client
+        cdp_client = get_cdp_client()
+        # Note: Don't use async with context manager as get_cdp_client returns a managed global client
         price = await cdp_client.evm.get_swap_price(
             from_token=from_token,
             to_token=to_token,

intentkit/skills/xmtp/swap.py

@@ -2,7 +2,7 @@ from typing import List, Tuple, Type
 
 from pydantic import BaseModel, Field
 
-from intentkit.clients.cdp import get_origin_cdp_client
+from intentkit.clients.cdp import get_cdp_client
 from intentkit.models.chat import ChatMessageAttachment, ChatMessageAttachmentType
 from intentkit.skills.xmtp.base import XmtpBaseTool
 
@@ -107,15 +107,15 @@ class XmtpSwap(XmtpBaseTool):
         # https://github.com/coinbase/cdp-sdk/blob/main/examples/python/evm/swaps/create_swap_quote.py
         network_for_cdp = self.get_cdp_network(agent.network_id)
 
-        # Get CDP client from global origin helper (server-side credentials)
-        cdp_client = get_origin_cdp_client()
+        # Get CDP client from the global helper (server-side credentials)
+        cdp_client = get_cdp_client()
 
         # Call CDP to create swap quote and extract call datas
         # Be permissive with response shape across SDK versions
         try:
             # Attempt the canonical method per CDP SDK examples
             # create_swap_quote(from_token, to_token, from_amount, network, taker, slippage_bps, signer_address)
-            # Note: Don't use async with context manager as get_origin_cdp_client returns a managed global client
+            # Note: Don't use async with context manager as get_cdp_client returns a managed global client
             quote = await cdp_client.evm.create_swap_quote(
                 from_token=from_token,
                 to_token=to_token,

intentkit/utils/schema.py

@@ -0,0 +1,100 @@
+"""JSON Schema utilities for IntentKit.
+
+This module provides utilities for working with JSON schemas, including
+resolving $defs references and generating nested schemas.
+"""
+
+import copy
+from typing import Any, Dict
+
+
+def resolve_schema_refs(schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Recursively resolve $defs references in a JSON schema.
+
+    This function takes a JSON schema with $defs references and returns
+    a fully nested schema without any $ref pointers. This is useful for
+    creating schemas that can be easily consumed by external systems
+    that don't support JSON Schema references.
+
+    Args:
+        schema: The JSON schema dictionary that may contain $defs and $ref
+
+    Returns:
+        dict: A new schema with all $ref resolved to nested objects
+
+    Example:
+        >>> schema = {
+        ...     "type": "object",
+        ...     "properties": {
+        ...         "user": {"$ref": "#/$defs/User"}
+        ...     },
+        ...     "$defs": {
+        ...         "User": {
+        ...             "type": "object",
+        ...             "properties": {"name": {"type": "string"}}
+        ...         }
+        ...     }
+        ... }
+        >>> resolved = resolve_schema_refs(schema)
+        >>> # resolved will have the User definition inlined
+    """
+    # Deep copy to avoid modifying the original
+    resolved_schema = copy.deepcopy(schema)
+
+    # Extract $defs if they exist
+    defs = resolved_schema.pop("$defs", {})
+
+    def resolve_refs(obj: Any, defs_dict: Dict[str, Any]) -> Any:
+        """Recursively resolve $ref in an object."""
+        if isinstance(obj, dict):
+            if "$ref" in obj:
+                ref_path = obj["$ref"]
+                if ref_path.startswith("#/$defs/"):
+                    def_name = ref_path.replace("#/$defs/", "")
+                    if def_name in defs_dict:
+                        # Recursively resolve the referenced definition
+                        resolved_def = resolve_refs(defs_dict[def_name], defs_dict)
+                        return resolved_def
+                    else:
+                        # Keep the reference if definition not found
+                        return obj
+                else:
+                    # Keep non-$defs references as is
+                    return obj
+            else:
+                # Recursively process all values in the dictionary
+                return {
+                    key: resolve_refs(value, defs_dict) for key, value in obj.items()
+                }
+        elif isinstance(obj, list):
+            # Recursively process all items in the list
+            return [resolve_refs(item, defs_dict) for item in obj]
+        else:
+            # Return primitive values as is
+            return obj
+
+    # Resolve all references in the schema
+    return resolve_refs(resolved_schema, defs)
+
+
+def create_array_schema(
+    item_schema: Dict[str, Any], resolve_refs: bool = True
+) -> Dict[str, Any]:
+    """Create an array schema with the given item schema.
+
+    Args:
+        item_schema: The schema for array items
+        resolve_refs: Whether to resolve $defs references in the item schema
+
+    Returns:
+        dict: Array schema with resolved item schema
+    """
+    if resolve_refs:
+        resolved_item_schema = resolve_schema_refs(item_schema)
+    else:
+        resolved_item_schema = item_schema
+
+    return {
+        "type": "array",
+        "items": resolved_item_schema,
+    }